From b6b16143304b50744e974ddaa9c71c49766be4dc Mon Sep 17 00:00:00 2001 From: Victoria Plitt Date: Sun, 9 Jan 2022 16:17:15 +0200 Subject: #5821 RML extension - Color calibration window --- .../Models/CalibrationPlotModel.cs | 205 +++++++++ .../Models/ColorLinearizationModel.cs | 43 ++ .../Models/MachineModel.cs | 17 +- .../Tango.MachineStudio.ThreadExtensions.csproj | 24 ++ .../ViewModels/CalibrationDataVM.cs | 138 ++++++ .../ViewModels/ColorCalibrationTabVM.cs | 323 ++++++++++++++ .../ViewModels/ColorCalibrationViewVM.cs | 467 +++++++++++++++++++++ .../ViewModels/MainViewVM.cs | 73 ++-- .../Views/ColorCalibrationView.xaml | 349 +++++++++++++++ .../Views/ColorCalibrationView.xaml.cs | 77 ++++ .../Views/MachineTestResultsView.xaml | 3 + 11 files changed, 1691 insertions(+), 28 deletions(-) create mode 100644 Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/CalibrationPlotModel.cs create mode 100644 Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/ColorLinearizationModel.cs create mode 100644 Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/CalibrationDataVM.cs create mode 100644 Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/ColorCalibrationTabVM.cs create mode 100644 Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/ColorCalibrationViewVM.cs create mode 100644 Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/ColorCalibrationView.xaml create mode 100644 Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/ColorCalibrationView.xaml.cs (limited to 'Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions') diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/CalibrationPlotModel.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/CalibrationPlotModel.cs new file mode 100644 index 000000000..d6a7212c0 --- /dev/null +++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/CalibrationPlotModel.cs @@ -0,0 +1,205 @@ +using OxyPlot; +using OxyPlot.Wpf; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using Tango.BL.Entities; +using Tango.BL.Enumerations; +using Tango.Core; + +namespace Tango.MachineStudio.ThreadExtensions.Models +{ + + public class CalibrationPlotModel : ExtendedObject + { + #region Properties + + public Plot DataPlotControl { get; set; } + public Plot LinearizationPlotControl { get; set; } + + private string _title; + + public string Title + { + get { return _title; } + set { _title = value; RaisePropertyChangedAuto(); } + } + + private FactorColors _color; + + private IList _LPoints; + + public IList LPoints + { + get { return _LPoints; } + set { _LPoints = value; } + } + + private IList _APoints; + + public IList APoints + { + get { return _APoints; } + set { _APoints = value; } + } + + private IList _BPoints; + + public IList BPoints + { + get { return _BPoints; } + set { _BPoints = value; } + } + + private IList _points; + /// + /// Binding to ItemsSource of line chart. + /// + public IList LinearizationPoints + { + get { return _points; } + set + { + _points = value; + RaisePropertyChangedAuto(); + } + } + + private int _step; + public int XStep + { + get { return _step; } + set { _step = value; RaisePropertyChangedAuto(); } + } + + private double _minY; + /// + /// From use to binding to left axis min value + /// + public double MinY + { + get { return _minY; } + set + { + _minY = value; RaisePropertyChangedAuto(); + } + } + + private double _maxY; + /// + /// To use to binding to left axis max value + /// + public double MaxY + { + get { return _maxY; } + set + { + _maxY = value; RaisePropertyChangedAuto(); + } + } + private int _maxX; + /// + /// Gets or sets the maximum lab plot X values for LinearizationGraph left part + /// + public int MaxX + { + get { return _maxX; } + set + { + _maxX = value; + RaisePropertyChangedAuto(); + } + } + + private double _linearizationMaxX; + + public double LinearizationMaxX + { + get { return _linearizationMaxX; } + set + { + _linearizationMaxX = value; + RaisePropertyChangedAuto(); + } + } + + private double _linearizationMaxY; + + public double LinearizationMaxY + { + get { return _linearizationMaxY; } + set + { + _linearizationMaxY = value; + RaisePropertyChangedAuto(); + } + } + #endregion + + public CalibrationPlotModel(FactorColors color, string title) + { + LinearizationPoints = new List(); + LPoints = new List(); + APoints = new List(); + BPoints = new List(); + _color = color; + _title = title; + + } + public void ClearResults() + { + LPoints.Clear(); + APoints.Clear(); + BPoints.Clear(); + LinearizationPoints.Clear(); + } + + public void InitDataGraph(List items) + { + if (DataPlotControl == null) + { + Debug.WriteLine("ERROR!!! CreateGraph. Plot Control is NULL."); + return; + } + + if (items == null || items.Count == 0) + return; + + ClearResults(); + DataPlotControl.InvalidatePlot(true); + LinearizationPlotControl.InvalidatePlot(true); + + foreach (var labItem in items) + { + LPoints.Add(new DataPoint(labItem.InkPercentage, labItem.L)); + APoints.Add(new DataPoint(labItem.InkPercentage, labItem.A)); + BPoints.Add(new DataPoint(labItem.InkPercentage, labItem.B)); + } + int maxValue = (int)(items.Max(x => x.InkPercentage)); + MaxX = Math.Max(100, maxValue); + + MinY = Math.Min(0, items.Min(x => Math.Min(x.L, Math.Min(x.A, x.B)))); + MaxY = Math.Max( 100, items.Max(x => Math.Max(x.L, Math.Max(x.A, x.B)))); + + DataPlotControl.InvalidatePlot(true); + } + + public void InitLinearizationGraph(List items, List outputPoints) + { + + if (outputPoints == null) + return; + + foreach (var nw in items.Zip(outputPoints, Tuple.Create)) + { + LinearizationPoints.Add(new DataPoint(nw.Item1.InkPercentage, nw.Item2)); + } + + LinearizationMaxX = Math.Max(100, LinearizationPoints.Max(x => x.X)); + LinearizationMaxY = Math.Max(100, LinearizationPoints.Max(x => x.Y)); + + LinearizationPlotControl.InvalidatePlot(true); + } + } +} diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/ColorLinearizationModel.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/ColorLinearizationModel.cs new file mode 100644 index 000000000..39774f7d8 --- /dev/null +++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/ColorLinearizationModel.cs @@ -0,0 +1,43 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Tango.Documents; + +namespace Tango.MachineStudio.ThreadExtensions.Models +{ + public class ColorLinearizationModel + { + public class LinearizationDataItem + { + public double InkPercentage { get; set; } + public double L { get; set; } + public double A { get; set; } + public double B { get; set; } + } + + public ColorLinearizationModel() + { + + } + + public void GetDataFromFile(string fileName, out List items, ref string errors) + { + items = null; + try + { + using (ExcelReader reader = new ExcelReader(fileName)) + { + items = reader.GetDataByIndex("Sheet1", 2); + } + } + catch (Exception ex) + { + errors = ex.Message; + } + + } + } +} diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/MachineModel.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/MachineModel.cs index e41a6a220..c2b00fe92 100644 --- a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/MachineModel.cs +++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/MachineModel.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; +using Tango.BL.Entities; using Tango.Core; namespace Tango.MachineStudio.ThreadExtensions.Models @@ -10,14 +11,14 @@ namespace Tango.MachineStudio.ThreadExtensions.Models public class MachineModel : ExtendedObject { public String Guid { get; set; } - + public string Name { get; set; } protected String _serialnumber; - + public String SerialNumber { - get{ return _serialnumber; } + get { return _serialnumber; } set { _serialnumber = value; @@ -35,6 +36,16 @@ namespace Tango.MachineStudio.ThreadExtensions.Models } } + protected IEnumerable _idspacks; + public IEnumerable IdsPacks + { + get { return _idspacks; } + set + { + _idspacks = value; + } + } + public MachineModel() { HasRMLTest = false; diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Tango.MachineStudio.ThreadExtensions.csproj b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Tango.MachineStudio.ThreadExtensions.csproj index 9ea43ad0b..4af5d899b 100644 --- a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Tango.MachineStudio.ThreadExtensions.csproj +++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Tango.MachineStudio.ThreadExtensions.csproj @@ -97,6 +97,8 @@ + + @@ -105,6 +107,9 @@ + + + @@ -112,6 +117,9 @@ AddItemDialog.xaml + + ColorCalibrationView.xaml + ColorParametersView.xaml @@ -145,6 +153,10 @@ Designer MSBuild:Compile + + Designer + MSBuild:Compile + Designer MSBuild:Compile @@ -208,6 +220,10 @@ + + {37E4CEAB-B54B-451F-B535-04CF7DA9C459} + ColorMine + {bb2abb74-ba58-4812-83aa-ec8171f42df4} Tango.AutoComplete @@ -216,6 +232,10 @@ {f441feee-322a-4943-b566-110e12fd3b72} Tango.BL + + {b60c695c-61e8-4091-b506-4c45349c04aa} + Tango.ColorCalibration + {a34ee0f0-649d-41c8-8489-b6f1cc6924ee} Tango.Core @@ -228,6 +248,10 @@ {bc932dbd-7cdb-488c-99e4-f02cf441f55e} Tango.Logging + + {e4927038-348d-4295-aaf4-861c58cb3943} + Tango.PMR + {d8f1ad85-526a-4f50-b6dc-d437af63d8d8} Tango.Settings diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/CalibrationDataVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/CalibrationDataVM.cs new file mode 100644 index 000000000..b8fab210c --- /dev/null +++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/CalibrationDataVM.cs @@ -0,0 +1,138 @@ +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Tango.BL.Entities; +using Tango.Core; +using Tango.PMR.ColorLab; + +namespace Tango.MachineStudio.ThreadExtensions.ViewModels +{ + public class CalibrationDataPointVM : ExtendedObject + { + private double _x; + + public double X + { + get { return _x; } + set { _x = value; RaisePropertyChangedAuto(); } + } + + private double _y; + + public double Y + { + get { return _y; } + set { _y = value; RaisePropertyChangedAuto(); } + } + + private int _index; + + public int Index + { + get { return _index; } + set { _index = value; RaisePropertyChangedAuto(); } + } + + + public CalibrationDataPointVM() + { + + } + + public CalibrationDataPointVM(double x, double y) + { + X = x; + Y = y; + } + + public CalibrationDataPointVM(CalibrationPoint calibrationPoint) : this(calibrationPoint.X, calibrationPoint.Y) + { + + } + + public CalibrationPoint ToPMR() + { + return new CalibrationPoint() + { + X = X, + Y = Y, + }; + } + } + + public class CalibrationDataVM : ExtendedObject + { + private BL.Entities.LiquidType _liquidType; + + public BL.Entities.LiquidType LiquidType + { + get { return _liquidType; } + set { _liquidType = value; RaisePropertyChangedAuto(); } + } + + private IdsPack _idsPack; + + public IdsPack IdsPack + { + get { return _idsPack; } + set { _idsPack = value; RaisePropertyChangedAuto(); } + } + + private ObservableCollection _calibrationPoints; + + public ObservableCollection CalibrationPoints + { + get { return _calibrationPoints; } + set { _calibrationPoints = value; RaisePropertyChangedAuto(); OnCalibrationPointsChanged(); } + } + + private void OnCalibrationPointsChanged() + { + if (CalibrationPoints != null) + { + CalibrationPoints.CollectionChanged -= CalibrationPoints_CollectionChanged; + CalibrationPoints.CollectionChanged += CalibrationPoints_CollectionChanged; + + SetIndices(); + } + } + + private void CalibrationPoints_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) + { + SetIndices(); + } + + private void SetIndices() + { + if (CalibrationPoints != null) + { + int index = 1; + foreach (var p in CalibrationPoints) + { + p.Index = index++; + } + } + } + + private CalibrationDataVM() + { + CalibrationPoints = new ObservableCollection(); + } + + public CalibrationDataVM(IdsPack pack) : this() + { + IdsPack = pack; + LiquidType = pack.LiquidType; + } + + public CalibrationDataVM(BL.Entities.LiquidType liquidType) : this() + { + LiquidType = liquidType; + CalibrationPoints = new ObservableCollection(); + //CalibrationPoints.Add(new CalibrationDataPointVM() { Index = 1, X = 2, Y = 22 }); + } + } +} \ No newline at end of file diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/ColorCalibrationTabVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/ColorCalibrationTabVM.cs new file mode 100644 index 000000000..103052b52 --- /dev/null +++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/ColorCalibrationTabVM.cs @@ -0,0 +1,323 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Tango.SharedUI; +using Tango.MachineStudio.ThreadExtensions.Models; +using Tango.BL.Enumerations; +using Tango.Core.Commands; +using Microsoft.Win32; +using Tango.MachineStudio.Common.Notifications; +using Tango.PMR.ColorLab; +using Tango.ColorCalibration; +using Tango.BL.ActionLogs; + +namespace Tango.MachineStudio.ThreadExtensions.ViewModels +{ + public class ColorCalibrationTabVM : ViewModel + { + private INotificationProvider _notification; + private IActionLogManager _actionLogManager; + private ILinearizationMeasurements _linearizationMeasurementscalibrator; + + #region Properties + + private string _name; + /// + /// Gets or sets the name of the thread. Using in print + /// + public string Name + { + get { return _name; } + set + { + _name = value; + RaisePropertyChangedAuto(); + } + } + + private int _tabIndex; + + public int TabIndex + { + get { return _tabIndex; } + set { _tabIndex = value; } + } + + + private bool _isSelected; + /// + /// Gets or sets a value indicating whether this instance is selected. + /// + public bool IsSelected + { + get { return _isSelected; } + set { _isSelected = value; RaisePropertyChangedAuto(); } + } + + private CalibrationPlotModel _cyanPlot; + + public CalibrationPlotModel CyanPlot + { + get { return _cyanPlot; } + set + { + _cyanPlot = value; + RaisePropertyChangedAuto(); + } + } + + private CalibrationPlotModel _magentaPlot; + + public CalibrationPlotModel MagentaPlot + { + get { return _magentaPlot; } + set { _magentaPlot = value; } + } + + private CalibrationPlotModel _yellowPlot; + + public CalibrationPlotModel YellowPlot + { + get { return _yellowPlot; } + set { _yellowPlot = value; } + } + + private CalibrationPlotModel _blackPlot; + + public CalibrationPlotModel BlackPlot + { + get { return _blackPlot; } + set { _blackPlot = value; } + } + + private CalibrationDataVM _cyanCalibrationData; + + public CalibrationDataVM CyanCalibrationData + { + get { return _cyanCalibrationData; } + set { _cyanCalibrationData = value; } + } + + private CalibrationDataVM _magentaCalibrationData; + + public CalibrationDataVM MagentaCalibrationData + { + get { return _magentaCalibrationData; } + set { _magentaCalibrationData = value; } + } + + private CalibrationDataVM _yellowCalibrationData; + + public CalibrationDataVM YellowCalibrationData + { + get { return _yellowCalibrationData; } + set { _yellowCalibrationData = value; } + } + + private CalibrationDataVM _blackCalibrationData; + + public CalibrationDataVM BlackCalibrationData + { + get { return _blackCalibrationData; } + set { _blackCalibrationData = value; RaisePropertyChangedAuto(); } + } + + + #endregion + + #region Commands + + public RelayCommand ImportCyanDataCommand { get; set; } + public RelayCommand ImportMagentaDataCommand { get; set; } + public RelayCommand ImportYellowDataCommand { get; set; } + public RelayCommand ImportBlackDataCommand { get; set; } + + #endregion + + public ColorCalibrationTabVM(INotificationProvider notification, IActionLogManager actionLogManager) + { + _notification = notification; + _actionLogManager = actionLogManager; + _linearizationMeasurementscalibrator = new DefaultColorCalibrator(); + + CyanPlot = new CalibrationPlotModel(FactorColors.CYAN, "Cyan"); + YellowPlot = new CalibrationPlotModel(FactorColors.YELLOW, "Yellow"); + MagentaPlot = new CalibrationPlotModel(FactorColors.MAGENTA, "Magenta"); + BlackPlot = new CalibrationPlotModel(FactorColors.BLACK, "Black"); + + CyanCalibrationData = new CalibrationDataVM(new Tango.BL.Entities.LiquidType() { Code = (int)LiquidTypes.Cyan }); + MagentaCalibrationData = new CalibrationDataVM(new Tango.BL.Entities.LiquidType() { Code = (int)LiquidTypes.Magenta }); + YellowCalibrationData = new CalibrationDataVM(new Tango.BL.Entities.LiquidType() { Code = (int)LiquidTypes.Yellow }); + BlackCalibrationData = new CalibrationDataVM(new Tango.BL.Entities.LiquidType() { Code = (int)LiquidTypes.Black }); + + ImportCyanDataCommand = new RelayCommand(ImportCyanData); + ImportMagentaDataCommand = new RelayCommand(ImportMagentaData); + ImportYellowDataCommand = new RelayCommand(ImportYellowData); + ImportBlackDataCommand = new RelayCommand(ImportBlackData); + } + + #region Methods + private async void ImportCyanData(object obj) + { + + List items; + if (ImportDataFromFile(out items) && items.Count > 0) + { + CyanPlot.InitDataGraph(items); + + List outputPoints = new List(); + + await Task.Factory.StartNew(() => + { + outputPoints = GetLinearizationMeasurements(items, PMR.ColorLab.LiquidType.Cyan); + }); + + CyanPlot.InitLinearizationGraph(items, outputPoints); + CyanCalibrationData.CalibrationPoints.Clear(); + var index = 1; + foreach (var nw in items.Zip(outputPoints, Tuple.Create)) + { + CyanCalibrationData.CalibrationPoints.Add(new CalibrationDataPointVM() { Index = index++, X = nw.Item1.InkPercentage, Y = nw.Item2 }); + } + } + + } + + private async void ImportMagentaData(object obj) + { + + List items; + if (ImportDataFromFile(out items) && items.Count > 0) + { + MagentaPlot.InitDataGraph(items); + + List outputPoints = new List(); + + await Task.Factory.StartNew(() => + { + outputPoints = GetLinearizationMeasurements(items, PMR.ColorLab.LiquidType.Magenta); + }); + + MagentaPlot.InitLinearizationGraph(items, outputPoints); + MagentaCalibrationData.CalibrationPoints.Clear(); + var index = 1; + foreach (var nw in items.Zip(outputPoints, Tuple.Create)) + { + MagentaCalibrationData.CalibrationPoints.Add(new CalibrationDataPointVM() { Index = index++, X = nw.Item1.InkPercentage, Y = nw.Item2}); + } + } + } + + private async void ImportYellowData(object obj) + { + + List items; + if (ImportDataFromFile(out items) && items.Count > 0) + { + YellowPlot.InitDataGraph(items); + + List outputPoints = new List(); + + await Task.Factory.StartNew(() => + { + outputPoints = GetLinearizationMeasurements(items, PMR.ColorLab.LiquidType.Yellow); + }); + YellowPlot.InitLinearizationGraph(items, outputPoints); + YellowCalibrationData.CalibrationPoints.Clear(); + var index = 1; + foreach (var nw in items.Zip(outputPoints, Tuple.Create)) + { + YellowCalibrationData.CalibrationPoints.Add(new CalibrationDataPointVM() { Index = index++, X = nw.Item1.InkPercentage, Y = nw.Item2 }); + } + } + } + + + private async void ImportBlackData(object obj) + { + + List items; + if (ImportDataFromFile(out items) && items.Count > 0) + { + BlackPlot.InitDataGraph(items); + + List outputPoints = new List(); + + await Task.Factory.StartNew(() => + { + outputPoints = GetLinearizationMeasurements(items, PMR.ColorLab.LiquidType.Black); + }); + BlackPlot.InitLinearizationGraph(items, outputPoints); + BlackCalibrationData.CalibrationPoints.Clear(); + var index = 1; + foreach (var nw in items.Zip(outputPoints, Tuple.Create)) + { + BlackCalibrationData.CalibrationPoints.Add(new CalibrationDataPointVM() { Index = index++, X = nw.Item1.InkPercentage, Y = nw.Item2 }); + } + } + + } + + /// + /// Open file dialog and get name of file + /// + /// + private bool ImportDataFromFile(out List items) + { + OpenFileDialog dlg = new OpenFileDialog(); + dlg.Title = "Select data file"; + dlg.Filter = "Excel |*.xlsx"; + items = null; + if (dlg.ShowDialogCenter() && dlg.FileName.IsNotNullOrEmpty()) + { + ColorLinearizationModel model = new ColorLinearizationModel(); + string errors = ""; + model.GetDataFromFile(dlg.FileName, out items, ref errors); + if (false == String.IsNullOrEmpty(errors) || items == null || items.Count == 0) + { + _notification.ShowError("An error occurred while trying to import data form the selected excel file. Please check the file format if valid and is available to read."); + return false; + } + return true; + } + + return false; + } + + #endregion + + #region CreateLinearizationGraph + + private List GetLinearizationMeasurements(List items, PMR.ColorLab.LiquidType liquidType) + { + try + { + LinearizationInput linearizationInput = new LinearizationInput(); + items.ForEach(x => linearizationInput.Measurements.Add(new LinearizationMeasurement { L = x.L, A = x.A, B = x.B, InkPercentage = x.InkPercentage })); + linearizationInput.LiquidType = liquidType; + + LinearizationOutput result = _linearizationMeasurementscalibrator.GetLinearizationMeasurements(linearizationInput); + + if (!String.IsNullOrEmpty(result.ErrorMessage)) + { + LogManager.Log(result.ErrorMessage, "GetLinearizationMeasurements returns error." + result.ErrorMessage); + InvokeUI(() => + { + _notification.ShowError("Linearizion process failed. " + result.ErrorMessage); + }); + } + + return result.InkPercentage.ToList(); + } + catch (Exception ex) + { + LogManager.Log(ex, "Error occurred while trying to call GetLinearizationMeasurements."); + } + return null; + } + + #endregion + } +} diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/ColorCalibrationViewVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/ColorCalibrationViewVM.cs new file mode 100644 index 000000000..99bb896d7 --- /dev/null +++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/ColorCalibrationViewVM.cs @@ -0,0 +1,467 @@ + +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Collections.Specialized; +using System.ComponentModel; +using System.Linq; +using System.Threading.Tasks; +using Tango.BL; +using Tango.BL.ActionLogs; +using Tango.BL.Builders; +using Tango.BL.Entities; +using Tango.Core; +using Tango.MachineStudio.Common.Notifications; +using Tango.SharedUI; +using Tango.AutoComplete.Editors; +using Tango.MachineStudio.ThreadExtensions.Models; +using Tango.Core.Commands; +using Microsoft.Win32; +using Tango.Logging; +using Tango.BL.Enumerations; +using Tango.PMR.ColorLab; +using Tango.BL.Calibration; + + +namespace Tango.MachineStudio.ThreadExtensions.ViewModels +{ + public class ColorCalibrationViewVM : ViewModel + { + private INotificationProvider _notification; + private IActionLogManager _actionLogManager; + + private ObservablesContext _active_context; + + public event EventHandler SaveColorCalibration; + + + #region Properties + + private ObservableCollection _calibrationTabs; + + public ObservableCollection CalibrationTabs + { + get { return _calibrationTabs; } + set { _calibrationTabs = value; } + } + + private ColorCalibrationTabVM _selectedTab; + + public ColorCalibrationTabVM SelectedTab + { + get { return _selectedTab; } + set + { + _selectedTab = value; + RaisePropertyChangedAuto(); + + foreach (var tab in _calibrationTabs.Where(x => x != _selectedTab)) + { + tab.IsSelected = false; + } + + if (_selectedTab != null) + { + _selectedTab.IsSelected = true; + } + } + } + + private string _RMLExtentionGUID; + + public string RMLExtemtionGUID + { + get { return _RMLExtentionGUID; } + set + { + _RMLExtentionGUID = value; + OnRMLExtensionGUIDChanged(); + } + } + + private string _RMLGUID; + + public string RMLGUID + { + get { return _RMLGUID; } + set + { + _RMLGUID = value; + OnRMLExtensionGUIDChanged(); + } + } + + private Rml _activeRML; + public Rml ActiveRML + { + get { return _activeRML; } + set + { + _activeRML = value; + RaisePropertyChangedAuto(); + } + } + + private MachineModel _machine; + public MachineModel Machine + { + get { return _machine; } + set { _machine = value; + SelectedMachineChanged(); + RaisePropertyChangedAuto(); + InvalidateRelayCommands(); + } + } + + + private bool _isViewLoaded; + /// + /// Gets or sets a value indicating whether this instance is view loaded. Used to update charts. + /// + public bool IsViewLoaded + { + get { return _isViewLoaded; } + set + { + if (_isViewLoaded != value) + { + _isViewLoaded = value; + } + } + } + + + #endregion + + #region commands + public RelayCommand CreateColorDataImportExcelTemplateCommand { get; set; } + public RelayCommand ApplyToRMLCommand { get; set; } + public RelayCommand ApplyToMachineCalibrationCommand { get; set; } + + public RelayCommand SaveCommand { get; set; } + + public RelayCommand AddTabCommand { get; set; } + + public RelayCommand RemoveTabCommand { get; set; } + + public RelayCommand RenameTabCommand { get; set; } + + #endregion + + public ColorCalibrationViewVM(INotificationProvider notification, IActionLogManager actionLogManager) + { + _notification = notification; + _actionLogManager = actionLogManager; + CalibrationTabs = new ObservableCollection(); + + ApplyToRMLCommand = new RelayCommand(ApplyToRML); + ApplyToMachineCalibrationCommand = new RelayCommand(ApplyToMachineCalibration); + SaveCommand = new RelayCommand(Save, () => IsFree); + + AddTabCommand = new RelayCommand(() => AddNewTab()); + RemoveTabCommand = new RelayCommand(RemoveTab); + RenameTabCommand = new RelayCommand(RenameTab); + + CreateColorDataImportExcelTemplateCommand = new RelayCommand(CreateColorDataImportExcelTemplate); + } + + + + #region Methods + + private void OnRMLExtensionGUIDChanged() + { + } + + private void SelectedMachineChanged() + { + LoadColorCalibrations(); + } + + private void CreateColorDataImportExcelTemplate() + { + SaveFileDialog dlg = new SaveFileDialog(); + try + { + dlg.Title = $"Create excel template file"; + dlg.Filter = "Excel Files|*.xlsx"; + dlg.DefaultExt = ".xlsx"; + dlg.FileName = "Color Data File Template"; + if (dlg.ShowDialog().Value) + { + CalibrationHelper.CreateColorDataInputExcelTemplate(dlg.FileName); + } + } + catch (Exception ex) + { + LogManager.Log(ex, "Error generating excel calibration template file " + dlg.FileName); + _notification.ShowError("An error occurred while trying to generate the calibration file."); + } + } + /// + /// Applies calibration points to RML. + /// + private void ApplyToRML(object obj) + { + if(SelectedTab != null && ActiveRML != null) + { + var liquidTypesRmls = ActiveRML.LiquidTypesRmls; + var calibrationDataVM = SelectedTab.CyanCalibrationData; + ApplayCalibrationDataToliquidTypesRml(liquidTypesRmls, LiquidTypes.Cyan, SelectedTab.CyanCalibrationData); + ApplayCalibrationDataToliquidTypesRml(liquidTypesRmls, LiquidTypes.Magenta, SelectedTab.MagentaCalibrationData); + ApplayCalibrationDataToliquidTypesRml(liquidTypesRmls, LiquidTypes.Yellow, SelectedTab.YellowCalibrationData); + ApplayCalibrationDataToliquidTypesRml(liquidTypesRmls, LiquidTypes.Black, SelectedTab.BlackCalibrationData); + Save(); + } + } + + private void ApplayCalibrationDataToliquidTypesRml(SynchronizedObservableCollection liquidTypesRmls, LiquidTypes type, CalibrationDataVM calibrationDataVM) + { + if (calibrationDataVM.CalibrationPoints.Count == 0) + return; + + var liquidTypeRml = liquidTypesRmls.SingleOrDefault(x => x.LiquidType.Type == type); + CalibrationData calData = new CalibrationData(); + calData.LiquidType = (PMR.ColorLab.LiquidType)liquidTypeRml.LiquidType.Code; + calData.CalibrationPoints.Clear(); + calData.CalibrationPoints.AddRange(calibrationDataVM.CalibrationPoints.Select(x => new CalibrationPoint() { X = x.X, Y = x.Y })); + liquidTypeRml.PutCalibrationData(calData); + } + /// + /// Applies calibration points to machine calibration. + /// + private void ApplyToMachineCalibration(object obj) + { + if (SelectedTab != null) + { + var idsPack = Machine.IdsPacks. + Where(x => ActiveRML.LiquidTypesRmls.ToList().Exists(y => x.LiquidType != null && y.LiquidType.Guid == x.LiquidType.Guid)) + .OrderBy(x => x.PackIndex).ToList(); + + ApplayCalibrationDataToToMachineRml(idsPack, LiquidTypes.Cyan, SelectedTab.CyanCalibrationData); + ApplayCalibrationDataToToMachineRml(idsPack, LiquidTypes.Magenta, SelectedTab.MagentaCalibrationData); + ApplayCalibrationDataToToMachineRml(idsPack, LiquidTypes.Yellow, SelectedTab.YellowCalibrationData); + ApplayCalibrationDataToToMachineRml(idsPack, LiquidTypes.Black, SelectedTab.BlackCalibrationData); + Save(); + } + } + + private void ApplayCalibrationDataToToMachineRml(List idsPacks, LiquidTypes type, CalibrationDataVM calibrationDataVM) + { + if (calibrationDataVM.CalibrationPoints.Count == 0) + return; + + var idsPack = idsPacks.FirstOrDefault(x => x.LiquidType.Type == type); + + if (idsPack != null) + { + var cat = idsPack.LiquidType.Cats.FirstOrDefault(x => x.MachineGuid == Machine.Guid && x.RmlGuid == ActiveRML.Guid); ; + + if (cat == null) + { + cat = new Cat(); + cat.Name = "untitled"; + _active_context.Cats.Add(cat); + } + + cat.RmlGuid = ActiveRML.Guid; + cat.MachineGuid = Machine.Guid; + cat.LiquidType = idsPack.LiquidType; + + CalibrationData calData = new CalibrationData(); + calData.LiquidType = (PMR.ColorLab.LiquidType)idsPack.LiquidType.Code; + calData.CalibrationPoints.AddRange(calibrationDataVM.CalibrationPoints.Select(x => new CalibrationPoint() { X = x.X, Y = x.Y })); + + cat.PutCalibrationData(calData); + } + } + + #endregion + + #region Loading + + public async void LoadColorCalibrations() + { + if (Machine == null) + { + _notification.ShowWarning(LogManager.Log($"Please, select machine.", LogCategory.Warning)); + IsFree = false; + return; + } + if (ActiveRML == null) + { + IsFree = false; + return; + } + IsFree = false; + if (_active_context != null) + { + _active_context.Dispose(); + } + + _active_context = ObservablesContext.CreateDefault(); + + await Task.Factory.StartNew(() => + { + using (_notification.PushTaskItem("Loading Color Calibrations Tests ...")) + { + } + }); + if (CalibrationTabs.Count == 0) + { + SelectedTab = CreateNewColorCalibrationTabVM("Untitled", 1); + CalibrationTabs.Add(SelectedTab); + //_active_context.RmlExtensionCalibrationTests.Add(SelectedTab.TestResult); + // await _active_context.SaveChangesAsync(); + } + //LoadColorCalibarions(); + IsFree = true; + } + + public void UpdatePlots() + { + if (IsViewLoaded) + { + //CyanPlot.CreateGraph(CyanProcessData.ToList(), true); + //MagentaPlot.CreateGraph(MagentaProcessData.ToList(), true); + //YellowPlot.CreateGraph(YellowProcessData.ToList(), false); + //BlackPlot.CreateGraph(BlackProcessData.ToList(), true); + } + } + + private ColorCalibrationTabVM CreateNewColorCalibrationTabVM(string name, int index) + { + ColorCalibrationTabVM newtab = new ColorCalibrationTabVM(_notification, _actionLogManager) { Name = name , TabIndex = index}; + + return newtab; + } + + #endregion + + #region Tabs modification + + /// + /// Removes the specified tab. + /// + /// The tab. + private void RemoveTab(ColorCalibrationTabVM tab) + { + if (CalibrationTabs.Count == 1) + return; + if (_notification.ShowQuestion("Are you sure you want to delete the selected tab?")) + { + // _active_context.RmlExtensionTestResults.Remove(tab.TestResult); + + CalibrationTabs.Remove(tab); + SelectedTab = CalibrationTabs.LastOrDefault(); + _active_context.SaveChanges(); + } + } + + /// + /// Adds a new tab. + /// + private bool AddNewTab(String name = null) + { + if (CalibrationTabs.Count > 7) + { + //_notification.ShowError("Cannot exceed the maximum number of 8 tabs. You can remove a tab, or create a new project."); + return false; + } + + if (name == null) + { + name = _notification.ShowTextInput("Enter tab name", "Tab Name", "Test"); + } + + if (!String.IsNullOrWhiteSpace(name)) + { + var tab = CreateNewColorCalibrationTabVM(name, (CalibrationTabs.Count + 1)); + CalibrationTabs.Add(tab); + //_active_context.RmlExtensionTestResults.Add(tab.TestResult); + SelectedTab = tab; + return true; + } + else + { + return false; + } + } + + /// + /// Renames the tab. + /// + /// The tab. + private void RenameTab() + { + if (SelectedTab != null) + { + var name = _notification.ShowTextInput("Enter tab name", "Tab Name", SelectedTab.Name); + + if (!String.IsNullOrWhiteSpace(name)) + { + SelectedTab.Name = name; + } + } + } + + #endregion + + #region Save + + public async void Save() + { + if (Machine == null) + { + _notification.ShowWarning(LogManager.Log($"Could not save Color Calibrations. Please, select machine before save.", LogCategory.Warning)); + return; + } + + try + { + IsFree = false; + + //SelectedColorProcessParameter.LastUpdated = DateTime.UtcNow; + + //foreach (var item in RemovedColorProcessDataBeforeSave) + //{ + // var existingColorProcessData = await _active_context.ColorProcessData.FirstOrDefaultAsync(y => y.Guid == item); + // if (existingColorProcessData != null) + // { + // _active_context.ColorProcessData.Remove(existingColorProcessData); + // } + //} + //foreach (var colordata in SelectedColorProcessParameter.ColorProcessData) + //{ + // colordata.LastUpdated = DateTime.UtcNow; + //} + //foreach (var factordata in SelectedColorProcessParameter.ColorProcessFactors) + //{ + // factordata.LastUpdated = DateTime.UtcNow; + //} + //foreach (var inkdata in SelectedColorProcessParameter.ColorProcessInkUptake) + //{ + // inkdata.LastUpdated = DateTime.UtcNow; + //} + + await _active_context.SaveChangesAsync(); + + // LoadColorParameters(); + } + catch (Exception ex) + { + LogManager.Log(ex, "Could not update color calibrations."); + _notification.ShowError($"An error occurred while trying to save color calibrations.\n{ex.Message}"); + } + finally + { + IsFree = true; + EventHandler handler = SaveColorCalibration; + handler?.Invoke(this, new EventArgs()); + } + } + + #endregion + + } +} diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/MainViewVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/MainViewVM.cs index 4802e0af1..e8aafca9d 100644 --- a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/MainViewVM.cs +++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/MainViewVM.cs @@ -257,6 +257,13 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels set { _testResultsViewVM = value; RaisePropertyChangedAuto(); } } + private ColorCalibrationViewVM _colorCalibrationViewVM; + public ColorCalibrationViewVM ColorCalibrationViewVM + { + get { return _colorCalibrationViewVM; } + set { _colorCalibrationViewVM = value; RaisePropertyChangedAuto(); } + } + protected MachineModel _selectedMachine; /// /// Gets or sets the selected machine. @@ -294,20 +301,20 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels } - private MachineTestResultsTabs PreviosSelectedTab { get; set; } + //private MachineTestResultsTabs PreviosSelectedTab { get; set; } - private MachineTestResultsTabs _selectedTab; + //private MachineTestResultsTabs _selectedTab; - public MachineTestResultsTabs SelectedTab - { - get { return _selectedTab; } - set { - PreviosSelectedTab = _selectedTab; - _selectedTab = value; - OnSelectedMachineTestResultsTabChanged(); - RaisePropertyChangedAuto(); - } - } + //public MachineTestResultsTabs SelectedTab + //{ + // get { return _selectedTab; } + // set { + // PreviosSelectedTab = _selectedTab; + // _selectedTab = value; + // OnSelectedMachineTestResultsTabChanged(); + // RaisePropertyChangedAuto(); + // } + //} #endregion @@ -922,7 +929,8 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels { Guid = x.Guid, Name = x.Name, - SerialNumber = x.SerialNumber + SerialNumber = x.SerialNumber, + IdsPacks = x.Configuration.IdsPacks.Where(z => !z.IsEmpty) }).ToObservableCollection(); } @@ -994,9 +1002,7 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels .WithUser() .BuildAsync(); - ActiveRML = new RmlBuilder(_active_context) - .Set(SelectedRMLExtension.RMLGuid) - .Build(); + ActiveRML = new RmlBuilder(_active_context).Set(SelectedRMLExtension.RMLGuid).WithLiquidFactors().Build(); if (!String.IsNullOrEmpty(ActiveRML.Manufacturer) && false == Manufacturers.Any(x => x == ActiveRML.Manufacturer)) { @@ -1040,12 +1046,23 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels TestResultsViewVM.SelectedMachineGUID = SelectedMachine != null ? SelectedMachine.Guid : null; TestResultsViewVM.ThreadName = ActiveRML.Manufacturer; + ColorCalibrationViewVM = new ColorCalibrationViewVM(_notification, _actionLogManager); + ColorCalibrationViewVM.RMLExtemtionGUID = guid; + ColorCalibrationViewVM.ActiveRML = ActiveRML; + ColorCalibrationViewVM.RMLGUID = ActiveRML.Guid; + ColorCalibrationViewVM.Machine = SelectedMachine; + + + + if (ActiveRMLExtension.RMLStatus == RMLExtensionStatus.New) { ColorParametersVewVM.SaveColorParameters -= UpdateStatus; ColorParametersVewVM.SaveColorParameters += UpdateStatus; TestResultsViewVM.SaveTestResults -= UpdateStatus; TestResultsViewVM.SaveTestResults += UpdateStatus; + ColorCalibrationViewVM.SaveColorCalibration -= UpdateStatus; + ColorCalibrationViewVM.SaveColorCalibration += UpdateStatus; } View.NavigateTo(RMLExtensionNavigationView.RMLExtentionView); @@ -1108,6 +1125,7 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels { ColorParametersVewVM.SaveColorParameters -= UpdateStatus; TestResultsViewVM.SaveTestResults -= UpdateStatus; + ColorCalibrationViewVM.SaveColorCalibration -= UpdateStatus; ActiveRMLExtension.RMLStatus = RMLExtensionStatus.InProgress; ActiveRMLExtension.LastUpdated = DateTime.UtcNow; @@ -1134,6 +1152,10 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels { TestResultsViewVM.SelectedMachineGUID = SelectedMachine.Guid; } + if(ColorCalibrationViewVM != null) + { + ColorCalibrationViewVM.Machine = SelectedMachine; + } } #endregion @@ -1183,10 +1205,10 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels #region selections - private void OnSelectedMachineTestResultsTabChanged() - { - if(SelectedTab == MachineTestResultsTabs.ColorParameters) - { + //private void OnSelectedMachineTestResultsTabChanged() + // { + //if(SelectedTab == MachineTestResultsTabs.ColorParameters) + // { //if(PreviosSelectedTab == MachineTestResultsTabs.TestResults && TestResultsViewVM != null) //{ // TestResultsViewVM.Save(); @@ -1194,15 +1216,15 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels //save //if (_notification.ShowQuestion("Are you sure you want to exit this page without saving changes?")) - } - else if(SelectedTab == MachineTestResultsTabs.TestResults) - { + // } + // else if(SelectedTab == MachineTestResultsTabs.TestResults) + // { //if (PreviosSelectedTab == MachineTestResultsTabs.ColorParameters && ColorParametersVewVM != null) //{ // ColorParametersVewVM.Save(); //} - } - } + //} + // } #endregion @@ -1304,6 +1326,7 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels colorParametrsExcelList.Add(colorParametrsExcelModel); TestResultsViewVM.LoadTestResultsExcel(testResultsExcelModelList, machine.Guid, machine.SerialNumber); + //ColorCalibrationViewVM.WritetoExcel } } diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/ColorCalibrationView.xaml b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/ColorCalibrationView.xaml new file mode 100644 index 000000000..278d58d02 --- /dev/null +++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/ColorCalibrationView.xaml @@ -0,0 +1,349 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + LIQUID TYPE CYAN + + + + + + + + + + + + + + + + + + + + + + LIQUID TYPE MAGENTA + + + + + + + + + + + + + + + + + + + + + + LIQUID TYPE YELLOW + + + + + + + + + + + + + + + + + + + + + + LIQUID TYPE BLACK + + + + + + + + + + + + + + + + + + diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/ColorCalibrationView.xaml.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/ColorCalibrationView.xaml.cs new file mode 100644 index 000000000..06bd67231 --- /dev/null +++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/ColorCalibrationView.xaml.cs @@ -0,0 +1,77 @@ +using OxyPlot.Wpf; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Controls.Primitives; +using System.Windows.Data; +using System.Windows.Documents; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Imaging; +using System.Windows.Navigation; +using System.Windows.Shapes; +using Tango.MachineStudio.ThreadExtensions.ViewModels; + +namespace Tango.MachineStudio.ThreadExtensions.Views +{ + /// + /// Interaction logic for ColorCalibrationView.xaml + /// + public partial class ColorCalibrationView : UserControl + { + public ColorCalibrationView() + { + InitializeComponent(); + //this.Loaded += ColorCalibrationView_Loaded; + } + + //private void ColorCalibrationView_Loaded(object sender, RoutedEventArgs e) + //{ + // if (contentGrid != null && contentGrid.DataContext is ColorCalibrationViewVM) + // { + // ColorCalibrationViewVM vm = (ColorCalibrationViewVM)contentGrid.DataContext; + // DataTemplate myDataTemplate = cyanChartsContent.ContentTemplate; + + + // vm.CyanPlot.DataPlotControl = (Plot)cyanChartsContent.ContentTemplate.FindName("LABDataPlot", cyanChartsContent); + // vm.CyanPlot.LinearizationPlotControl = (Plot)cyanChartsContent.ContentTemplate.FindName("LinearizationPlot", cyanChartsContent); + // vm.MagentaPlot.DataPlotControl = (Plot)magentaChartsContent.ContentTemplate.FindName("LABDataPlot", cyanChartsContent); + // vm.MagentaPlot.LinearizationPlotControl = (Plot)magentaChartsContent.ContentTemplate.FindName("LinearizationPlot", cyanChartsContent); + // vm.YellowPlot.DataPlotControl = (Plot)yellowChartsContent.ContentTemplate.FindName("LABDataPlot", cyanChartsContent); + // vm.YellowPlot.LinearizationPlotControl = (Plot)yellowChartsContent.ContentTemplate.FindName("LinearizationPlot", cyanChartsContent); + // vm.BlackPlot.DataPlotControl = (Plot)blackChartsContent.ContentTemplate.FindName("LABDataPlot", cyanChartsContent); + // vm.BlackPlot.LinearizationPlotControl = (Plot)blackChartsContent.ContentTemplate.FindName("LinearizationPlot", cyanChartsContent); + + // vm.IsViewLoaded = true; + // } + //} + + private void ContentGrid_Loaded(object sender, RoutedEventArgs e) + { + var grid = (UIElement)sender; + if (grid != null && ((UniformGrid)grid).DataContext is ColorCalibrationViewVM) + { + ColorCalibrationViewVM vm = (ColorCalibrationViewVM)((UniformGrid)grid).DataContext; + ColorCalibrationTabVM selectedTab = vm.SelectedTab; + // var Plot = (cyanChartsContent as FrameworkElement).FindChild("LABDataPlot"); + if (selectedTab != null) + { + selectedTab.CyanPlot.DataPlotControl = (cyanChartsContent as FrameworkElement).FindChild("LABDataPlot"); + selectedTab.CyanPlot.LinearizationPlotControl = (cyanChartsContent as FrameworkElement).FindChild("LinearizationPlot"); + selectedTab.MagentaPlot.DataPlotControl = (magentaChartsContent as FrameworkElement).FindChild("LABDataPlot"); + selectedTab.MagentaPlot.LinearizationPlotControl = (magentaChartsContent as FrameworkElement).FindChild("LinearizationPlot"); + selectedTab.YellowPlot.DataPlotControl = (yellowChartsContent as FrameworkElement).FindChild("LABDataPlot"); + selectedTab.YellowPlot.LinearizationPlotControl = (yellowChartsContent as FrameworkElement).FindChild("LinearizationPlot"); + selectedTab.BlackPlot.DataPlotControl = (blackChartsContent as FrameworkElement).FindChild("LABDataPlot"); + selectedTab.BlackPlot.LinearizationPlotControl = (blackChartsContent as FrameworkElement).FindChild("LinearizationPlot"); + + vm.IsViewLoaded = true; + } + } + } + } +} diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/MachineTestResultsView.xaml b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/MachineTestResultsView.xaml index bfb8a58d0..b46cb4cf9 100644 --- a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/MachineTestResultsView.xaml +++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/MachineTestResultsView.xaml @@ -58,6 +58,9 @@ + + + -- cgit v1.3.1