Merge branch 'master' of https://twinetfs.visualstudio.com/_git/Tango

7 files changed, 891 insertions, 2 deletions

diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/CalibrationDataPointVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/CalibrationDataPointVM.cs
new file mode 100644
index 000000000..4ad06c7ed
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/CalibrationDataPointVM.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Tango.Core;
+using Tango.PMR.ColorLab;
+using Tango.SharedUI;
+
+namespace Tango.MachineStudio.RML.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,
+            };
+        }
+    }
+}
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/CalibrationDataVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/CalibrationDataVM.cs
new file mode 100644
index 000000000..403494a8e
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/CalibrationDataVM.cs
@@ -0,0 +1,83 @@
+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.SharedUI;
+
+namespace Tango.MachineStudio.RML.ViewModels
+{
+    public class CalibrationDataVM : ExtendedObject
+    {
+        private LiquidType _liquidType;
+
+        public LiquidType LiquidType
+        {
+            get { return _liquidType; }
+            set { _liquidType = value; RaisePropertyChangedAuto(); }
+        }
+
+        private IdsPack _idsPack;
+
+        public IdsPack IdsPack
+        {
+            get { return _idsPack; }
+            set { _idsPack = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ObservableCollection<CalibrationDataPointVM> _calibrationPoints;
+
+        public ObservableCollection<CalibrationDataPointVM> 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<CalibrationDataPointVM>();
+        }
+
+        public CalibrationDataVM(IdsPack pack) : this()
+        {
+            IdsPack = pack;
+            LiquidType = pack.LiquidType;
+        }
+
+        public CalibrationDataVM(LiquidType liquidType) : this()
+        {
+            LiquidType = liquidType;
+        }
+    }
+}
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/CalibrationDataViewVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/CalibrationDataViewVM.cs
new file mode 100644
index 000000000..b34ef83bc
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/CalibrationDataViewVM.cs
@@ -0,0 +1,110 @@
+using Microsoft.Win32;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Tango.BL.Calibration;
+using Tango.Core.Commands;
+using Tango.MachineStudio.Common;
+using Tango.MachineStudio.Common.Notifications;
+using Tango.SharedUI;
+
+namespace Tango.MachineStudio.RML.ViewModels
+{
+    public class CalibrationDataViewVM : ViewModel
+    {
+        private INotificationProvider _notification;
+
+        private ObservableCollection<CalibrationDataVM> _liquidsCalibrationData;
+        /// <summary>
+        /// Gets or sets the liquids calibration data.
+        /// </summary>
+        public ObservableCollection<CalibrationDataVM> LiquidsCalibrationData
+        {
+            get { return _liquidsCalibrationData; }
+            set { _liquidsCalibrationData = value; RaisePropertyChangedAuto(); }
+        }
+
+        /// <summary>
+        /// Gets or sets the import excel command.
+        /// </summary>
+        public RelayCommand<CalibrationDataVM> ImportExcelCommand { get; set; }
+
+        /// <summary>
+        /// Gets or sets the export excel command.
+        /// </summary>
+        public RelayCommand<CalibrationDataVM> ExportExcelCommand { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CalibrationDataViewVM"/> class.
+        /// </summary>
+        public CalibrationDataViewVM(INotificationProvider notificationProvider)
+        {
+            _notification = notificationProvider;
+
+            LiquidsCalibrationData = new ObservableCollection<CalibrationDataVM>();
+
+            ImportExcelCommand = new RelayCommand<CalibrationDataVM>(ImportExcel);
+            ExportExcelCommand = new RelayCommand<CalibrationDataVM>(ExportExcel);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CalibrationDataViewVM"/> class.
+        /// </summary>
+        /// <param name="liquidsCalibrationData">The liquids calibration data.</param>
+        public CalibrationDataViewVM(INotificationProvider notificationProvider, ObservableCollection<CalibrationDataVM> liquidsCalibrationData) : this(notificationProvider)
+        {
+            LiquidsCalibrationData = liquidsCalibrationData;
+        }
+
+        private void ImportExcel(CalibrationDataVM vm)
+        {
+            OpenFileDialog dlg = new OpenFileDialog();
+
+            try
+            {
+                dlg.Title = $"Import excel calibration file for {vm.LiquidType.Name}";
+                dlg.Filter = "Excel Files|*.xlsx";
+                if (dlg.ShowDialog().Value)
+                {
+                    vm.CalibrationPoints.Clear();
+                    var points = CalibrationHelper.ImportCalibrationDataFromExcel(dlg.FileName);
+
+                    foreach (var p in points)
+                    {
+                        vm.CalibrationPoints.Add(new CalibrationDataPointVM(p));
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                LogManager.Log(ex, "Error importing excel file " + dlg.FileName);
+                _notification.ShowError("An error occurred while trying to import the selected excel file. Please check the file format if valid and is available to read.");
+            }
+        }
+
+        private void ExportExcel(CalibrationDataVM vm)
+        {
+            SaveFileDialog dlg = new SaveFileDialog();
+            try
+            {
+                dlg.Title = $"Export excel calibration file for {vm.LiquidType.Name}";
+                dlg.Filter = "Excel Files|*.xlsx";
+                dlg.DefaultExt = ".xlsx";
+                dlg.FileName = $"CData_{vm.LiquidType.Name}_v{vm.LiquidType.Version}.xlsx";
+                if (dlg.ShowDialog().Value)
+                {
+                    var points = vm.CalibrationPoints.Select(x => x.ToPMR()).ToList();
+                    CalibrationHelper.ExportCalibrationDataToExcel(points, dlg.FileName);
+                }
+            }
+            catch (Exception ex)
+            {
+                LogManager.Log(ex, "Error exporting excel file " + dlg.FileName);
+                _notification.ShowError("An error occurred while trying to export the calibration data.");
+            }
+        }
+    }
+}
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/ColorConversionViewVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/ColorConversionViewVM.cs
new file mode 100644
index 000000000..2624c9b7d
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/ColorConversionViewVM.cs
@@ -0,0 +1,396 @@
+using Google.Protobuf;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Data.Entity;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Media;
+using Tango.BL;
+using Tango.BL.Entities;
+using Tango.BL.Enumerations;
+using Tango.ColorConversion;
+using Tango.MachineStudio.Common;
+using Tango.MachineStudio.Common.Notifications;
+using Tango.MachineStudio.RML.Models;
+using Tango.PMR.ColorLab;
+using Tango.SharedUI;
+
+namespace Tango.MachineStudio.RML.ViewModels
+{
+    public class ColorConversionViewVM: ViewModel
+    {
+        #region properties
+
+        private INotificationProvider _notification;
+        private bool _prevent_inverse_conversion;
+
+        private bool _isVolumesOutOfRange;
+        /// <summary>
+        /// Gets or sets a value indicating whether the liquid volumes are out of range.
+        /// </summary>
+        public bool IsVolumesOutOfRange
+        {
+            get { return _isVolumesOutOfRange; }
+            set
+            {
+                if (_isVolumesOutOfRange != value)
+                {
+                    _isVolumesOutOfRange = value;
+                    RaisePropertyChangedAuto();
+                }
+            }
+        }
+
+        private bool _isOutOfGamut;
+        /// <summary>
+        /// Gets or sets a value indicating whether the source color is out of gamut.
+        /// </summary>
+        public bool IsOutOfGamut
+        {
+            get { return _isOutOfGamut; }
+            set { _isOutOfGamut = value; RaisePropertyChangedAuto(); }
+        }
+
+        private Rml _rml;
+        public Rml RML
+        {
+            get { return _rml; }
+            set { _rml = value; RaisePropertyChangedAuto(); }
+        }
+
+        private List<ColorConversionSuggestion> _hiveSuggestions;
+        /// <summary>
+        /// Gets or sets the hive suggestions.
+        /// </summary>
+        public List<ColorConversionSuggestion> HiveSuggestions
+        {
+            get { return _hiveSuggestions; }
+            set { _hiveSuggestions = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ColorConversionSuggestion _selectedSuggestion;
+        /// <summary>
+        /// Gets or sets the selected suggestion.
+        /// </summary>
+        public ColorConversionSuggestion SelectedSuggestion
+        {
+            get { return _selectedSuggestion; }
+            set { _selectedSuggestion = value; RaisePropertyChangedAuto(); OnSelectedSuggestionChanged(); }
+        }
+
+        private ObservableCollection<LiquidTypesRml> _liquidTypesRmls;
+        /// <summary>
+        /// Gets or sets the liquid types RMLS.
+        /// </summary>
+        public ObservableCollection<LiquidTypesRml> LiquidTypesRmls
+        {
+            get { return _liquidTypesRmls; }
+            set { _liquidTypesRmls = value; RaisePropertyChangedAuto(); OnLiquidTypesRmlsChanged(); }
+        }
+
+        private void OnLiquidTypesRmlsChanged()
+        {
+            if (LiquidTypesRmls != null)
+            {
+                LiquidTypesRmls.CollectionChanged += LiquidTypesRmls_CollectionChanged;
+                InvalidateLiquidVolumes();
+            }
+        }
+
+        private void LiquidTypesRmls_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
+        {
+            InvalidateLiquidVolumes();
+        }
+
+        private void InvalidateLiquidVolumes()
+        {
+            LiquidVolumes = LiquidTypesRmls.Where(x => x.LiquidType.HasPigment).Select(x => new LiquidVolumeVM()
+            {
+                Color = x.LiquidType.Color,
+                Name = x.LiquidType.Name,
+                LiquidType = x.LiquidType,
+            }).ToObservableCollection();
+        }
+
+        private ObservableCollection<LiquidVolumeVM> _liquidVolumes;
+        /// <summary>
+        /// Gets or sets the liquid volumes.
+        /// </summary>
+        public ObservableCollection<LiquidVolumeVM> LiquidVolumes
+        {
+            get { return _liquidVolumes; }
+            set { _liquidVolumes = value; RaisePropertyChangedAuto(); OnLiquidsVolumesChanged(); }
+        }
+
+        private ObservableCollection<CalibrationDataVM> _liquidsCalibrationData;
+        /// <summary>
+        /// Gets or sets the liquids calibration data.
+        /// </summary>
+        public ObservableCollection<CalibrationDataVM> LiquidsCalibrationData
+        {
+            get { return _liquidsCalibrationData; }
+            set { _liquidsCalibrationData = value; RaisePropertyChangedAuto(); }
+        }
+
+        private CctModel _cct;
+        public CctModel CCT
+        {
+            get { return _cct; }
+            set
+            {
+                _cct = value;
+                RaisePropertyChangedAuto();
+                InvalidateRelayCommands();
+            }
+        }
+
+        private RgbVM _sourceColor;
+        /// <summary>
+        /// Gets or sets the color of the source.
+        /// </summary>
+        public RgbVM SourceColor
+        {
+            get { return _sourceColor; }
+            set { _sourceColor = value; RaisePropertyChangedAuto(); }
+        }
+
+        private RgbVM _targetColor;
+        /// <summary>
+        /// Gets or sets the color of the target.
+        /// </summary>
+        /// <value>
+        /// The color of the target.
+        /// </value>
+        public RgbVM TargetColor
+        {
+            get { return _targetColor; }
+            set { _targetColor = value; RaisePropertyChangedAuto(); }
+        }
+
+        #endregion
+
+        public ColorConversionViewVM(INotificationProvider notification)
+        {
+            _notification = notification;
+
+            // CCT = new Cct();
+
+            SourceColor = new RgbVM();
+            SourceColor.ColorChanged += SourceColor_ColorChanged;
+        }
+
+        private void OnLiquidsVolumesChanged()
+        {
+            LiquidVolumes.EnableCrossThreadOperations();
+            LiquidVolumes.ToList().ForEach(x => x.VolumeChanged += (s, e) => OnLiquidVolumeChanged());
+        }
+
+        private void SourceColor_ColorChanged(object sender, Color e)
+        {
+            GetHiveSuggestions();
+        }
+
+        private void GetHiveSuggestions()
+        {
+            Task.Factory.StartNew(() =>
+            {
+                try
+                {
+                    if (RML == null || LiquidsCalibrationData == null || CCT == null || CCT.Data == null) return;
+
+                    ConversionInput input = new ConversionInput();
+                    input.ColorSpace = SourceColor.IsLab ? PMR.ColorLab.ColorSpace.Lab : PMR.ColorLab.ColorSpace.Rgb;
+                    //input.DeltaChroma = DeltaChroma;
+                    //input.DeltaL = DeltaL;
+                    input.ForwardData = ByteString.CopyFrom(CCT.Data);
+
+                    input.InputCoordinates = new InputCoordinates();
+                    input.InputCoordinates.Red = (int)SourceColor.Red;
+                    input.InputCoordinates.Green = (int)SourceColor.Green;
+                    input.InputCoordinates.Blue = (int)SourceColor.Blue;
+
+                    input.InputCoordinates.L = SourceColor.L;
+                    input.InputCoordinates.A = SourceColor.A;
+                    input.InputCoordinates.B = SourceColor.B;
+
+                    input.ThreadL = RML.WhitePointL;
+                    input.ThreadA = RML.WhitePointA;
+                    input.ThreadB = RML.WhitePointB;
+
+                    //Validate calibration data
+                    foreach (var vm in LiquidsCalibrationData.Where(x => x.LiquidType.HasPigment))
+                    {
+                        if (vm.CalibrationPoints.Count == 0)
+                        {
+                            InvokeUI(() =>
+                            {
+                                _notification.ShowError($"No calibration data for liquid '{vm.LiquidType.Name}'. Could not convert source color.");
+                            });
+                            return;
+                        }
+                        else if (!(vm.CalibrationPoints.First().X == 0 && vm.CalibrationPoints.First().Y == 0 && vm.CalibrationPoints.Last().X == 100 && vm.CalibrationPoints.Last().Y == 100))
+                        {
+                            InvokeUI(() =>
+                            {
+                                _notification.ShowError($"Invalid calibration data for liquid '{vm.LiquidType.Name}'. Could not convert source color.");
+                            });
+                            return;
+                        }
+                    }
+
+                    foreach (var vm in LiquidsCalibrationData)
+                    {
+                        InputLiquid inputLiquid = new InputLiquid();
+
+
+                        CalibrationData calData = new CalibrationData();
+                        calData.LiquidType = (PMR.ColorLab.LiquidType)vm.LiquidType.Code;
+                        calData.CalibrationPoints.AddRange(vm.CalibrationPoints.Select(x => new CalibrationPoint() { X = x.X, Y = x.Y }));
+
+                        inputLiquid.CalibrationData = calData;
+
+                        inputLiquid.LiquidType = (PMR.ColorLab.LiquidType)vm.LiquidType.Code;
+                        inputLiquid.MaxNanoliterPerCentimeter = LiquidTypesRmls.SingleOrDefault(x => x.LiquidType.Code == vm.LiquidType.Code).MaxNlPerCm;
+
+                        input.InputCoordinates.InputLiquids.Add(inputLiquid);
+                    }
+
+                    foreach (var process in RML.GetActiveProcessGroup().ProcessParametersTables)
+                    {
+                        input.ProcessRanges.Add(new ProcessRange()
+                        {
+                            MinInkUptake = process.MinInkUptake,
+                            MaxInkUptake = process.MaxInkUptake,
+                        });
+                    }
+
+                    IColorConverter converter = new DefaultColorConverter();
+
+                    var output = converter.Convert(input);
+
+                    IsOutOfGamut = output.OutOfGamut;
+
+                    HiveSuggestions = output.CreateHiveSuggestions();
+                }
+                catch (Exception ex)
+                {
+                    LogManager.Log(ex, "An error occurred while trying to convert from source color to Volume.");
+
+                    InvokeUI(() =>
+                    {
+                        _notification.ShowError($"An error occurred while trying to convert from source color to Volume.\n" + ex.Message);
+                    });
+                }
+            });
+        }
+
+        private void OnSelectedSuggestionChanged()
+        {
+            if (SelectedSuggestion != null)
+            {
+                _prevent_inverse_conversion = true;
+
+                var coords = SelectedSuggestion.Coordinates;
+
+                foreach (var liquid in coords.OutputLiquids)
+                {
+                    var liquidVolume = LiquidVolumes.SingleOrDefault(x => x.LiquidType.Code == liquid.LiquidType.ToInt32());
+
+                    if (liquidVolume != null)
+                    {
+                        liquidVolume.Volume = liquid.Volume;
+                    }
+                }
+
+                _prevent_inverse_conversion = false;
+
+                OnLiquidVolumeChanged();
+            }
+        }
+
+        private void OnLiquidVolumeChanged()
+        {
+            try
+            {
+                if (LiquidsCalibrationData == null || _prevent_inverse_conversion) return;
+
+                //TODO: This is temporary because of out of range volumes.
+                if (LiquidVolumes.Where(x => x.LiquidType.HasPigment).Sum(x => x.Volume) > 200)
+                {
+                    IsVolumesOutOfRange = true;
+                    return;
+                }
+                else
+                {
+                    IsVolumesOutOfRange = false;
+                }
+
+                ConversionInput input = new ConversionInput();
+                input.ColorSpace = PMR.ColorLab.ColorSpace.Volume;
+                input.ForwardData = ByteString.CopyFrom(CCT.Data);
+
+                input.InputCoordinates = new InputCoordinates();
+                input.ThreadL = RML.WhitePointL;
+                input.ThreadA = RML.WhitePointA;
+                input.ThreadB = RML.WhitePointB;
+
+                foreach (var vm in LiquidsCalibrationData.Where(x => x.LiquidType.HasPigment))
+                {
+                    InputLiquid inputLiquid = new InputLiquid();
+
+                    CalibrationData calData = new CalibrationData();
+                    calData.LiquidType = (PMR.ColorLab.LiquidType)vm.LiquidType.Code;
+                    calData.CalibrationPoints.AddRange(vm.CalibrationPoints.Select(x => new CalibrationPoint() { X = x.X, Y = x.Y }));
+
+                    inputLiquid.CalibrationData = calData;
+
+                    inputLiquid.LiquidType = (PMR.ColorLab.LiquidType)vm.LiquidType.Code;
+                    inputLiquid.MaxNanoliterPerCentimeter = LiquidTypesRmls.SingleOrDefault(x => x.LiquidType.Code == vm.LiquidType.Code).MaxNlPerCm;
+                    inputLiquid.Volume = LiquidVolumes.SingleOrDefault(x => x.LiquidType == vm.LiquidType).Volume;
+
+                    input.InputCoordinates.InputLiquids.Add(inputLiquid);
+                }
+
+                foreach (var process in RML.ProcessParametersTablesGroups.Single().ProcessParametersTables)
+                {
+                    input.ProcessRanges.Add(new ProcessRange()
+                    {
+                        MinInkUptake = process.MinInkUptake,
+                        MaxInkUptake = process.MaxInkUptake,
+                    });
+                }
+
+                IColorConverter converter = new DefaultColorConverter();
+
+                var output = converter.Convert(input);
+
+                if (SourceColor.IsLab)
+                {
+                    TargetColor = new RgbVM()
+                    {
+                        IsLab = true,
+                        L = output.SingleCoordinates.L,
+                        A = output.SingleCoordinates.A,
+                        B = output.SingleCoordinates.B,
+                    };
+                }
+                else
+                {
+                    TargetColor = new RgbVM()
+                    {
+                        Red = output.SingleCoordinates.Red,
+                        Green = output.SingleCoordinates.Green,
+                        Blue = output.SingleCoordinates.Blue,
+                    };
+                }
+            }
+            catch (Exception ex)
+            {
+                LogManager.Log(ex, "Error in inversed color conversion!");
+                _notification.ShowError("An error occurred while trying to convert from Volume to RGB.\n" + ex.Message);
+            }
+        }
+    }
+}
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/LiquidVolumeVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/LiquidVolumeVM.cs
new file mode 100644
index 000000000..7399d62af
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/LiquidVolumeVM.cs
@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Tango.BL.Entities;
+using Tango.Core;
+using Tango.SharedUI;
+
+namespace Tango.MachineStudio.RML.ViewModels
+{
+    public class LiquidVolumeVM : ExtendedObject
+    {
+        public event EventHandler<double> VolumeChanged;
+
+        private String _name;
+
+        public String Name
+        {
+            get { return _name; }
+            set { _name = value; RaisePropertyChangedAuto(); }
+        }
+
+        private double _volume;
+
+        public double Volume
+        {
+            get { return _volume; }
+            set
+            {
+                _volume = value; RaisePropertyChangedAuto();
+                VolumeChanged?.Invoke(this, _volume);
+            }
+        }
+
+        private int _color;
+
+        public int Color
+        {
+            get { return _color; }
+            set { _color = value; RaisePropertyChangedAuto(); }
+        }
+
+        private LiquidType _liquidType;
+        public LiquidType LiquidType
+        {
+            get { return _liquidType; }
+            set { _liquidType = value; RaisePropertyChangedAuto(); }
+        }
+    }
+}
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/MainViewVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/MainViewVM.cs
index aa84fb137..361608ef6 100644
--- a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/MainViewVM.cs
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/MainViewVM.cs
@@ -13,13 +13,13 @@ using Tango.BL.Builders;
 using Tango.BL.Calibration;
 using Tango.BL.Entities;
 using Tango.Core.Commands;
-using Tango.MachineStudio.ColorLab.ViewModels;
 using Tango.MachineStudio.Common;
 using Tango.MachineStudio.Common.Notifications;
 using Tango.MachineStudio.RML.Contracts;
 using Tango.MachineStudio.RML.Models;
 using Tango.MachineStudio.RML.Views;
 using Tango.PMR.ColorLab;
+using System.Data.Entity;
 
 namespace Tango.MachineStudio.RML.ViewModels
 {
@@ -132,7 +132,14 @@ namespace Tango.MachineStudio.RML.ViewModels
         public CctModel SelectedCCT
         {
             get { return _selectedCCT; }
-            set { _selectedCCT = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
+            set { _selectedCCT = value; RaisePropertyChangedAuto(); OnSelectedCCTChanged(); InvalidateRelayCommands(); }
+        }
+
+        private ColorConversionViewVM _colorConversionViewVM;
+        public ColorConversionViewVM ColorConversionViewVM
+        {
+            get { return _colorConversionViewVM; }
+            set { _colorConversionViewVM = value; RaisePropertyChangedAuto(); }
         }
 
         /// <summary>
@@ -287,6 +294,13 @@ namespace Tango.MachineStudio.RML.ViewModels
                     CalibrationDataViewVM.LiquidsCalibrationData.Add(catVM);
                 }
 
+                ColorConversionViewVM = new ColorConversionViewVM(_notification)
+                {
+                    RML = ActiveRML,
+                    CCT = SelectedCCT,
+                    LiquidsCalibrationData = CalibrationDataViewVM.LiquidsCalibrationData,
+                    LiquidTypesRmls = LiquidTypesRmls,
+                };
 
                 View.NavigateTo(RmlNavigationView.RmlView);
 
@@ -296,6 +310,27 @@ namespace Tango.MachineStudio.RML.ViewModels
             }
         }
 
+        private async void OnSelectedCCTChanged()
+        {
+            if (SelectedCCT != null && !SelectedCCT.IsNew)
+            {
+                using (_notification.PushTaskItem("Loading CCT data..."))
+                {
+                    IsFree = false;
+
+                    var cct = await _active_context.Ccts.SingleOrDefaultAsync(x => x.Guid == SelectedCCT.Guid);
+
+                    if (cct != null)
+                    {
+                        SelectedCCT.Data = cct.Data;
+                        ColorConversionViewVM.CCT = SelectedCCT;
+                    }
+
+                    IsFree = true;
+                }
+            }
+        }
+
         private void LoadRmlProperties()
         {
             Materials = _active_context.MediaMaterials.ToObservableCollection();
@@ -566,6 +601,8 @@ namespace Tango.MachineStudio.RML.ViewModels
 
                 CCTS.Insert(0, cctModel);
                 SelectedCCT = cctModel;
+
+                ColorConversionViewVM.CCT = SelectedCCT;
             }
         }
 
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/RgbVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/RgbVM.cs
new file mode 100644
index 000000000..e64592aae
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.RML/ViewModels/RgbVM.cs
@@ -0,0 +1,148 @@
+using ColorMine.ColorSpaces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Media;
+using System.Windows.Threading;
+using Tango.Core;
+using Tango.SharedUI;
+
+namespace Tango.MachineStudio.RML.ViewModels
+{
+    public class RgbVM : ExtendedObject
+    {
+        private DispatcherTimer _color_change_timer;
+
+        public event EventHandler<Color> ColorChanged;
+
+        public RgbVM()
+        {
+            _color_change_timer = new DispatcherTimer();
+            _color_change_timer.Interval = TimeSpan.FromMilliseconds(30);
+            _color_change_timer.Tick += _color_change_timer_Tick;
+            _color_change_timer.Stop();
+
+            Color = Colors.DimGray;
+        }
+
+        private void _color_change_timer_Tick(object sender, EventArgs e)
+        {
+            _color_change_timer.Stop();
+            ColorChanged?.Invoke(this, Color);
+        }
+
+        private double _red;
+        public double Red
+        {
+            get { return _red; }
+            set { _red = value; SynchronizeColor(); RaisePropertyChangedAuto(); }
+        }
+
+        private double _green;
+        public double Green
+        {
+            get { return _green; }
+            set { _green = value; SynchronizeColor(); RaisePropertyChangedAuto(); }
+        }
+
+        private double _blue;
+        public double Blue
+        {
+            get { return _blue; }
+            set { _blue = value; SynchronizeColor(); RaisePropertyChangedAuto(); }
+        }
+
+        private double _l;
+        public double L
+        {
+            get { return _l; }
+            set { _l = value; SynchronizeColor(); RaisePropertyChangedAuto(); }
+        }
+
+        private double _a;
+        public double A
+        {
+            get { return _a; }
+            set { _a = value; SynchronizeColor(); RaisePropertyChangedAuto(); }
+        }
+
+        private double _b;
+        public double B
+        {
+            get { return _b; }
+            set { _b = value; SynchronizeColor(); RaisePropertyChangedAuto(); }
+        }
+
+        private Color _color;
+        public Color Color
+        {
+            get { return _color; }
+            set { _color = value; RaisePropertyChanged(nameof(Color)); SynchronizeComponents(); }
+        }
+
+        private bool _isLab;
+        public bool IsLab
+        {
+            get { return _isLab; }
+            set { _isLab = value; RaisePropertyChangedAuto(); }
+        }
+
+
+        private void SynchronizeColor()
+        {
+            _color_change_timer.Stop();
+
+            if (!IsLab)
+            {
+                Rgb rgb = new Rgb(Red, Green, Blue);
+                Lab lab = rgb.To<Lab>();
+                _l = lab.L;
+                _a = lab.A;
+                _b = lab.B;
+            }
+            else
+            {
+                Lab lab = new Lab(L, A, B);
+                Rgb rgb = lab.To<Rgb>();
+                _red = rgb.R;
+                _green = rgb.G;
+                _blue = rgb.B;
+            }
+
+            _color = Color.FromRgb((byte)Red, (byte)Green, (byte)Blue);
+            RaisePropertyChanged(nameof(Color));
+
+            _color_change_timer.Start();
+        }
+
+        private void SynchronizeComponents()
+        {
+            _color_change_timer.Stop();
+
+            _red = Color.R;
+            _green = Color.G;
+            _blue = Color.B;
+
+            if (IsLab)
+            {
+                Rgb rgb = new Rgb(Red, Green, Blue);
+                Lab lab = rgb.To<Lab>();
+                _l = lab.L;
+                _a = lab.A;
+                _b = lab.B;
+            }
+
+            RaisePropertyChanged(nameof(Red));
+            RaisePropertyChanged(nameof(Green));
+            RaisePropertyChanged(nameof(Blue));
+            RaisePropertyChanged(nameof(L));
+            RaisePropertyChanged(nameof(A));
+            RaisePropertyChanged(nameof(B));
+            RaisePropertyChanged(nameof(Color));
+
+            _color_change_timer.Start();
+        }
+    }
+}