Merged Yana_Thread_Extensions_3

20 files changed, 2919 insertions, 79 deletions

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..49ca76d14
--- /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<DataPoint> _LPoints;
+
+        public IList<DataPoint> LPoints
+        {
+            get { return _LPoints; }
+            set { _LPoints = value; }
+        }
+
+        private IList<DataPoint> _APoints;
+
+        public IList<DataPoint> APoints
+        {
+            get { return _APoints; }
+            set { _APoints = value; }
+        }
+
+        private IList<DataPoint> _BPoints;
+
+        public IList<DataPoint> BPoints
+        {
+            get { return _BPoints; }
+            set { _BPoints = value; }
+        }
+
+        private IList<DataPoint> _points;
+        /// <summary>
+        /// Binding to ItemsSource  of line chart.
+        /// </summary>
+        public IList<DataPoint> LinearizationPoints
+        {
+            get { return _points; }
+            set
+            {
+                _points = value;
+                RaisePropertyChangedAuto();
+            }
+        }
+        
+        private int _step;
+        public int XStep
+        {
+            get { return _step; }
+            set { _step = value; RaisePropertyChangedAuto(); }
+        }
+
+        private double _minY;
+        /// <summary>
+        /// From use to binding to left axis min value
+        /// </summary>
+        public double MinY
+        {
+            get { return _minY; }
+            set
+            {
+                _minY = value; RaisePropertyChangedAuto();
+            }
+        }
+
+        private double _maxY;
+        /// <summary>
+        /// To use to binding to left axis max value
+        /// </summary>
+        public double MaxY
+        {
+            get { return _maxY; }
+            set
+            {
+                _maxY = value; RaisePropertyChangedAuto();
+            }
+        }
+        private int _maxX;
+        /// <summary>
+        /// Gets or sets the maximum lab plot X values for LinearizationGraph left part
+        /// </summary>
+        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<DataPoint>();
+            LPoints = new List<DataPoint>();
+            APoints = new List<DataPoint>();
+            BPoints = new List<DataPoint>();
+            _color = color;
+            _title = title;
+
+        }
+        public void ClearResults()
+        {
+            LPoints.Clear();
+            APoints.Clear();
+            BPoints.Clear();
+            LinearizationPoints.Clear();
+        }
+
+        public void InitDataGraph(List<ColorLinearizationModel.LinearizationDataItem> items)
+        {
+            if (items == null || items.Count == 0)
+                return;
+
+            ClearResults();
+            if (DataPlotControl != null)
+                DataPlotControl.InvalidatePlot(true);
+            if (LinearizationPlotControl != null)
+                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))));
+
+            if (DataPlotControl != null)
+                DataPlotControl.InvalidatePlot(true);
+        }
+        
+        public void InitLinearizationGraph(List<ColorLinearizationModel.LinearizationDataItem> items, List<double> outputPoints)
+        {
+            if (outputPoints == null)
+                return;
+
+            LinearizationPoints.Clear();
+            foreach (var nw in items.Zip(outputPoints, Tuple.Create))
+            {
+                LinearizationPoints.Add(new DataPoint(nw.Item1.InkPercentage, nw.Item2));
+            }
+
+            LinearizationMaxX = Math.Max(100, LinearizationPoints.Count > 0? LinearizationPoints.Max(x => x.X) : 0);
+            LinearizationMaxY = Math.Max(100, LinearizationPoints.Count > 0 ? LinearizationPoints.Max(x => x.Y) : 0);
+
+            if (LinearizationPlotControl != null)
+            {
+                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..148f0f416
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/ColorLinearizationModel.cs
@@ -0,0 +1,42 @@
+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<LinearizationDataItem> items, ref string errors)
+        {
+            items = null;
+            try
+            {
+                using (ExcelReader reader = new ExcelReader(fileName))
+                {
+                    items = reader.GetDataByIndex<LinearizationDataItem>("Sheet1", 2);
+                }
+            }
+            catch (Exception ex)
+            {
+                errors = ex.Message;
+            }
+        }
+    }
+}
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/ColorShadesModel.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/ColorShadesModel.cs
new file mode 100644
index 000000000..98d4afe07
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Models/ColorShadesModel.cs
@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Tango.Documents;
+
+namespace Tango.MachineStudio.ThreadExtensions.Models
+{
+    public class ColorShadesModel
+    {
+        public class ColorShadesDataItem
+        {
+            public int ColorNumber { get; set; }
+            public double L { get; set; }
+            public double A { get; set; }
+            public double B { get; set; }
+            public double C { get; set; }
+            public double M { get; set; }
+            public double Y { get; set; }
+            public double K { get; set; }
+            public double TI { get; set; }
+            public double L2 { get; set; }
+            public double A2 { get; set; }
+            public double B2 { get; set; }
+            public double DelteE { get; set; }
+
+        }
+
+        public void GetDataFromFile(string fileName, out List<ColorShadesDataItem> items, ref string errors)
+        {
+            items = null;
+            try
+            {
+                using (ExcelReader reader = new ExcelReader(fileName))
+                {
+                    items = reader.GetDataByIndex<ColorShadesDataItem>("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<IdsPack> _idspacks;
+        public IEnumerable<IdsPack> 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..ae05ca02c 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
@@ -53,6 +53,15 @@
     <Reference Include="MaterialDesignThemes.Wpf, Version=2.3.1.953, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\..\..\packages\MaterialDesignThemes.2.3.1.953\lib\net45\MaterialDesignThemes.Wpf.dll</HintPath>
     </Reference>
+    <Reference Include="Microsoft.WindowsAPICodePack, Version=1.1.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\..\..\packages\Microsoft.WindowsAPICodePack-Core.1.1.0.0\lib\Microsoft.WindowsAPICodePack.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.WindowsAPICodePack.Shell, Version=1.1.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\..\..\packages\Microsoft.WindowsAPICodePack-Shell.1.1.0.0\lib\Microsoft.WindowsAPICodePack.Shell.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.WindowsAPICodePack.ShellExtensions, Version=1.1.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\..\..\packages\Microsoft.WindowsAPICodePack-Shell.1.1.0.0\lib\Microsoft.WindowsAPICodePack.ShellExtensions.dll</HintPath>
+    </Reference>
     <Reference Include="Newtonsoft.Json, Version=9.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
       <HintPath>..\..\..\packages\Newtonsoft.Json.9.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
@@ -97,6 +106,9 @@
     <Compile Include="Converters\NumericFieldConverter.cs" />
     <Compile Include="Excel\ColorDataExcelModel.cs" />
     <Compile Include="Excel\ColorParametrsExcelModel.cs" />
+    <Compile Include="Models\CalibrationPlotModel.cs" />
+    <Compile Include="Models\ColorLinearizationModel.cs" />
+    <Compile Include="Models\ColorShadesModel.cs" />
     <Compile Include="Models\FactorTarget.cs" />
     <Compile Include="Models\MachineModel.cs" />
     <Compile Include="Models\PlotProperties.cs" />
@@ -105,16 +117,27 @@
     <Compile Include="Excel\ThreadCharacteristicsExelModel.cs" />
     <Compile Include="ViewModelLocator.cs" />
     <Compile Include="ViewModels\AddItemDialogVM.cs" />
+    <Compile Include="ViewModels\CalibrationDataVM.cs" />
+    <Compile Include="ViewModels\ColorCalibrationTabVM.cs" />
+    <Compile Include="ViewModels\ColorCalibrationViewVM.cs" />
     <Compile Include="ViewModels\ColorParametersVewVM.cs" />
+    <Compile Include="ViewModels\ColorShadeTabVM.cs" />
     <Compile Include="ViewModels\MainViewVM.cs" />
     <Compile Include="ViewModels\TestResultsViewVM.cs" />
     <Compile Include="ViewModels\TestResultViewVM.cs" />
     <Compile Include="Views\AddItemDialog.xaml.cs">
       <DependentUpon>AddItemDialog.xaml</DependentUpon>
     </Compile>
+    <Compile Include="Views\ColorCalibrationView.xaml.cs">
+      <DependentUpon>ColorCalibrationView.xaml</DependentUpon>
+    </Compile>
     <Compile Include="Views\ColorParametersView.xaml.cs">
       <DependentUpon>ColorParametersView.xaml</DependentUpon>
     </Compile>
+    <Compile Include="Views\ColorShadeView.xaml.cs">
+      <DependentUpon>ColorShadeView.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="ViewModels\ColorShadeViewVM.cs" />
     <Compile Include="Views\ComboboxEditable.xaml.cs">
       <DependentUpon>ComboboxEditable.xaml</DependentUpon>
     </Compile>
@@ -145,10 +168,18 @@
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
+    <Page Include="Views\ColorCalibrationView.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
     <Page Include="Views\ColorParametersView.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
+    <Page Include="Views\ColorShadeView.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
     <Page Include="Views\ComboboxEditable.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
@@ -208,6 +239,10 @@
     <Resource Include="Images\threads.png" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\..\SideChains\ColorMine\ColorMine.csproj">
+      <Project>{37E4CEAB-B54B-451F-B535-04CF7DA9C459}</Project>
+      <Name>ColorMine</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\SideChains\Tango.AutoComplete\Tango.AutoComplete.csproj">
       <Project>{bb2abb74-ba58-4812-83aa-ec8171f42df4}</Project>
       <Name>Tango.AutoComplete</Name>
@@ -216,6 +251,10 @@
       <Project>{f441feee-322a-4943-b566-110e12fd3b72}</Project>
       <Name>Tango.BL</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\Tango.ColorCalibration\Tango.ColorCalibration.csproj">
+      <Project>{b60c695c-61e8-4091-b506-4c45349c04aa}</Project>
+      <Name>Tango.ColorCalibration</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\Tango.Core\Tango.Core.csproj">
       <Project>{a34ee0f0-649d-41c8-8489-b6f1cc6924ee}</Project>
       <Name>Tango.Core</Name>
@@ -228,6 +267,10 @@
       <Project>{bc932dbd-7cdb-488c-99e4-f02cf441f55e}</Project>
       <Name>Tango.Logging</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\Tango.PMR\Tango.PMR.csproj">
+      <Project>{e4927038-348d-4295-aaf4-861c58cb3943}</Project>
+      <Name>Tango.PMR</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\Tango.Settings\Tango.Settings.csproj">
       <Project>{d8f1ad85-526a-4f50-b6dc-d437af63d8d8}</Project>
       <Name>Tango.Settings</Name>
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<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(BL.Entities.LiquidType liquidType) : this()
+        {
+            LiquidType = liquidType;
+            CalibrationPoints = new ObservableCollection<CalibrationDataPointVM>();
+            //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..a2a119e29
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/ColorCalibrationTabVM.cs
@@ -0,0 +1,424 @@
+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;
+using Tango.BL.Entities;
+using Tango.Core;
+
+namespace Tango.MachineStudio.ThreadExtensions.ViewModels
+{
+    public class ColorCalibrationTabVM : ViewModel
+    {
+        private INotificationProvider _notification;
+        private IActionLogManager _actionLogManager;
+        private ILinearizationMeasurements _linearizationMeasurementscalibrator;
+        private List<BL.Entities.LiquidType> _liquids;
+
+        #region Properties
+
+        private string _name;
+        /// <summary>
+        /// Gets or sets the name of the thread. Using in print
+        /// </summary>
+        public string Name
+        {
+            get { return _name; }
+            set
+            {
+                _name = value;
+                if(RmlExtensionColorCalibrationsTest != null)
+                    RmlExtensionColorCalibrationsTest.Name = _name;
+                RaisePropertyChangedAuto();
+            }
+        }
+
+        private int _tabIndex;
+
+        public int TabIndex
+        {
+            get { return _tabIndex; }
+            set { _tabIndex = value;
+                RaisePropertyChangedAuto();
+            }
+        }
+
+
+        private bool _isSelected;
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is selected.
+        /// </summary>
+        public bool IsSelected
+        {
+            get { return _isSelected; }
+            set { _isSelected = value; RaisePropertyChangedAuto(); }
+        }
+        
+        public CalibrationPlotModel CyanPlot { get; set; }
+        
+        public CalibrationPlotModel MagentaPlot { get; set; }
+        
+        public CalibrationPlotModel YellowPlot { get; set; }
+        
+        public CalibrationPlotModel BlackPlot { get; set; }
+        
+        public CalibrationDataVM CyanCalibrationData { get; set; }
+        
+        public CalibrationDataVM MagentaCalibrationData { get; set; }
+        
+        public CalibrationDataVM YellowCalibrationData { get; set; }
+        
+        public CalibrationDataVM BlackCalibrationData { get; set; }
+        
+        private RmlExtensionColorCalibrationsTest _rmlExtensionColorCalibrationsTest;
+
+        public RmlExtensionColorCalibrationsTest RmlExtensionColorCalibrationsTest
+        {
+            get { return _rmlExtensionColorCalibrationsTest; }
+            set { _rmlExtensionColorCalibrationsTest = value;
+                OnRmlExtensionColorCalibrationsTestChanged();
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets last points before save. Used in Save to remove points before save new.
+        /// </summary>
+        /// <value>
+        /// The removed points.
+        /// </value>
+        public Dictionary<LiquidTypes, List<RmlExtensionColorCalibrationsTestsLiquidDataPoint>> RemovedPoints { get; set; }
+        
+        public bool IsTabLoaded { get; set; }
+       
+
+        #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, List<BL.Entities.LiquidType> liquids)
+        {
+            _notification = notification;
+            _actionLogManager = actionLogManager;
+            _linearizationMeasurementscalibrator = new DefaultColorCalibrator();
+            _liquids = liquids;
+            RemovedPoints = new Dictionary<LiquidTypes, List<RmlExtensionColorCalibrationsTestsLiquidDataPoint>>();
+            IsTabLoaded = false;
+
+            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<ColorLinearizationModel.LinearizationDataItem> items;
+            if (ImportDataFromFile(out items) && items.Count > 0)
+            {
+                List<double> calibrationPoints = new List<double>();
+                await Task.Factory.StartNew(() =>
+                {
+                    calibrationPoints = GetLinearizationMeasurements(items, PMR.ColorLab.LiquidType.Cyan);
+                });
+                UpdatePlots(CyanPlot, items, calibrationPoints);
+
+                CyanCalibrationData.CalibrationPoints.Clear();
+                var index = 1;
+                foreach (var nw in items.Zip(calibrationPoints, Tuple.Create))
+                {
+                    CyanCalibrationData.CalibrationPoints.Add(new CalibrationDataPointVM() { Index = index++, X = nw.Item1.InkPercentage, Y = nw.Item2 });
+                }
+
+                SynchronizedObservableCollection<RmlExtensionColorCalibrationsTestsLiquidData> data = RmlExtensionColorCalibrationsTest.RmlExtensionColorCalibrationsTestsLiquidData;
+                var liquidtype = _liquids.Where(l => l.Type == LiquidTypes.Cyan).FirstOrDefault();
+                var cyanliquidData = RmlExtensionColorCalibrationsTest.RmlExtensionColorCalibrationsTestsLiquidData.Where(x => x.LiquidTypeGuid == liquidtype.Guid).FirstOrDefault();
+                if (cyanliquidData != null)
+                {
+                    if (!RemovedPoints.ContainsKey(LiquidTypes.Cyan))
+                    {
+                        RemovedPoints[LiquidTypes.Cyan] = new List<RmlExtensionColorCalibrationsTestsLiquidDataPoint>(cyanliquidData.RmlExtensionColorCalibrationsTestsLiquidDataPoints.ToList());
+                    }
+                    cyanliquidData.RmlExtensionColorCalibrationsTestsLiquidDataPoints.Clear();
+                    items.ForEach(x => cyanliquidData.RmlExtensionColorCalibrationsTestsLiquidDataPoints.Add(new RmlExtensionColorCalibrationsTestsLiquidDataPoint() { Ink = x.InkPercentage, L = x.L, A = x.A, B = x.B, CalculatedPoint = CyanCalibrationData.CalibrationPoints.Where(y => y.X == x.InkPercentage).Select(z => z.Y).FirstOrDefault() }));
+                }
+            }
+
+        }
+
+        private async void ImportMagentaData(object obj)
+        {
+            List<ColorLinearizationModel.LinearizationDataItem> items;
+            if (ImportDataFromFile(out items) && items.Count > 0)
+            {
+                List<double> calibrationPoints = new List<double>();
+                await Task.Factory.StartNew(() =>
+                {
+                    calibrationPoints = GetLinearizationMeasurements(items, PMR.ColorLab.LiquidType.Magenta);
+                });
+                UpdatePlots(MagentaPlot, items, calibrationPoints);
+
+                MagentaCalibrationData.CalibrationPoints.Clear();
+                var index = 1;
+                foreach (var nw in items.Zip(calibrationPoints, Tuple.Create))
+                {
+                    MagentaCalibrationData.CalibrationPoints.Add(new CalibrationDataPointVM() { Index = index++, X = nw.Item1.InkPercentage, Y = nw.Item2 });
+                }
+                
+                SynchronizedObservableCollection<RmlExtensionColorCalibrationsTestsLiquidData> data = RmlExtensionColorCalibrationsTest.RmlExtensionColorCalibrationsTestsLiquidData;
+                var liquidtype = _liquids.Where(l => l.Type == LiquidTypes.Magenta).FirstOrDefault();
+                var magentaliquidData = RmlExtensionColorCalibrationsTest.RmlExtensionColorCalibrationsTestsLiquidData.Where(x => x.LiquidTypeGuid == liquidtype.Guid).FirstOrDefault();
+                if (magentaliquidData != null)
+                {
+                    if (!RemovedPoints.ContainsKey(LiquidTypes.Magenta))
+                    {
+                        RemovedPoints[LiquidTypes.Magenta] = new List<RmlExtensionColorCalibrationsTestsLiquidDataPoint>(magentaliquidData.RmlExtensionColorCalibrationsTestsLiquidDataPoints.ToList());
+                    }
+                    magentaliquidData.RmlExtensionColorCalibrationsTestsLiquidDataPoints.Clear();
+                    items.ForEach(x => magentaliquidData.RmlExtensionColorCalibrationsTestsLiquidDataPoints.Add(new RmlExtensionColorCalibrationsTestsLiquidDataPoint() { Ink = x.InkPercentage, L = x.L, A = x.A, B = x.B, CalculatedPoint = MagentaCalibrationData.CalibrationPoints.Where(y => y.X == x.InkPercentage).Select(z => z.Y).FirstOrDefault() }));
+                } 
+            }
+        }
+
+        private async void ImportYellowData(object obj)
+        {
+            List<ColorLinearizationModel.LinearizationDataItem> items;
+            if (ImportDataFromFile(out items) && items.Count > 0)
+            {
+                List<double> calibrationPoints = new List<double>();
+                await Task.Factory.StartNew(() =>
+                {
+                    calibrationPoints = GetLinearizationMeasurements(items, PMR.ColorLab.LiquidType.Yellow);
+                });
+                UpdatePlots(YellowPlot, items, calibrationPoints);
+
+                YellowCalibrationData.CalibrationPoints.Clear();
+                var index = 1;
+                foreach (var nw in items.Zip(calibrationPoints, Tuple.Create))
+                {
+                    YellowCalibrationData.CalibrationPoints.Add(new CalibrationDataPointVM() { Index = index++, X = nw.Item1.InkPercentage, Y = nw.Item2 });
+                }
+               
+                SynchronizedObservableCollection<RmlExtensionColorCalibrationsTestsLiquidData> data = RmlExtensionColorCalibrationsTest.RmlExtensionColorCalibrationsTestsLiquidData;
+                var liquidtype = _liquids.Where(l => l.Type == LiquidTypes.Yellow).FirstOrDefault();
+                var yellowliquidData = RmlExtensionColorCalibrationsTest.RmlExtensionColorCalibrationsTestsLiquidData.Where(x => x.LiquidTypeGuid == liquidtype.Guid).FirstOrDefault();
+                if (yellowliquidData != null)
+                {
+                    if (!RemovedPoints.ContainsKey(LiquidTypes.Yellow))
+                    {
+                        RemovedPoints[LiquidTypes.Yellow] = new List<RmlExtensionColorCalibrationsTestsLiquidDataPoint>(yellowliquidData.RmlExtensionColorCalibrationsTestsLiquidDataPoints.ToList());
+                    }
+                    yellowliquidData.RmlExtensionColorCalibrationsTestsLiquidDataPoints.Clear();
+                    items.ForEach(x => yellowliquidData.RmlExtensionColorCalibrationsTestsLiquidDataPoints.Add(new RmlExtensionColorCalibrationsTestsLiquidDataPoint() { Ink = x.InkPercentage, L = x.L, A = x.A, B = x.B, CalculatedPoint = YellowCalibrationData.CalibrationPoints.Where(y => y.X == x.InkPercentage).Select(z => z.Y).FirstOrDefault() }));
+                }
+            }
+        }
+        
+        private async void ImportBlackData(object obj)
+        {
+            List<ColorLinearizationModel.LinearizationDataItem> items;
+            if (ImportDataFromFile(out items) && items.Count > 0)
+            {
+                List<double> calibrationPoints = new List<double>();
+                await Task.Factory.StartNew(() =>
+                {
+                    calibrationPoints = GetLinearizationMeasurements(items, PMR.ColorLab.LiquidType.Black);
+                });
+                UpdatePlots(BlackPlot, items, calibrationPoints);
+
+                BlackCalibrationData.CalibrationPoints.Clear();
+                var index = 1;
+                foreach (var nw in items.Zip(calibrationPoints, Tuple.Create))
+                {
+                    BlackCalibrationData.CalibrationPoints.Add(new CalibrationDataPointVM() { Index = index++, X = nw.Item1.InkPercentage, Y = nw.Item2 });
+                }
+                
+                SynchronizedObservableCollection<RmlExtensionColorCalibrationsTestsLiquidData> data = RmlExtensionColorCalibrationsTest.RmlExtensionColorCalibrationsTestsLiquidData;
+                var liquidtype = _liquids.Where(l => l.Type == LiquidTypes.Black).FirstOrDefault();
+                var blackliquidData = RmlExtensionColorCalibrationsTest.RmlExtensionColorCalibrationsTestsLiquidData.Where(x => x.LiquidTypeGuid == liquidtype.Guid).FirstOrDefault();
+                if (blackliquidData != null)
+                {
+                    if (!RemovedPoints.ContainsKey(LiquidTypes.Black))
+                    {
+                        RemovedPoints[LiquidTypes.Black] = new List<RmlExtensionColorCalibrationsTestsLiquidDataPoint>(blackliquidData.RmlExtensionColorCalibrationsTestsLiquidDataPoints.ToList());
+                    }
+                    blackliquidData.RmlExtensionColorCalibrationsTestsLiquidDataPoints.Clear();
+                    items.ForEach(x => blackliquidData.RmlExtensionColorCalibrationsTestsLiquidDataPoints.Add(new RmlExtensionColorCalibrationsTestsLiquidDataPoint() { Ink = x.InkPercentage, L = x.L, A = x.A, B = x.B, CalculatedPoint = BlackCalibrationData.CalibrationPoints.Where(y => y.X == x.InkPercentage).Select(z => z.Y).FirstOrDefault() }));
+                }
+            }
+
+        }
+
+         /// <summary>
+        /// Open file dialog and get name of file
+        /// </summary>
+        /// <returns></returns>
+        private bool ImportDataFromFile(out List<ColorLinearizationModel.LinearizationDataItem> 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;
+        }
+
+        public  void InitData()
+        {
+            if(RmlExtensionColorCalibrationsTest != null)
+            {
+                SynchronizedObservableCollection<RmlExtensionColorCalibrationsTestsLiquidData> data = RmlExtensionColorCalibrationsTest.RmlExtensionColorCalibrationsTestsLiquidData;
+                foreach( var liquidData in data)
+                {
+                    var liquidGUID = liquidData.LiquidTypeGuid;
+                    var liquidType = _liquids.Where(l => l.Guid == liquidGUID).FirstOrDefault();
+                   
+                    var points = liquidData.RmlExtensionColorCalibrationsTestsLiquidDataPoints.OrderBy(y => y.Ink).ToList();
+                    LoadDataPlots(points, GetPlot(liquidType), GetCalibrationDataVM(liquidType));
+                }
+            }
+        }
+
+        private CalibrationPlotModel GetPlot(BL.Entities.LiquidType liquidType)
+        {
+            switch(liquidType.Type)
+            { 
+                case LiquidTypes.Cyan:
+                    return CyanPlot;
+                case LiquidTypes.Magenta:
+                    return MagentaPlot;
+                case LiquidTypes.Yellow:
+                    return YellowPlot;
+                case LiquidTypes.Black:
+                    return BlackPlot;
+                default:
+                    return null;
+            }
+        }
+        private CalibrationDataVM GetCalibrationDataVM(BL.Entities.LiquidType liquidType)
+        {
+            switch (liquidType.Type)
+            {
+                case LiquidTypes.Cyan:
+                    return CyanCalibrationData;
+                case LiquidTypes.Magenta:
+                    return MagentaCalibrationData;
+                case LiquidTypes.Yellow:
+                    return YellowCalibrationData;
+                case LiquidTypes.Black:
+                    return BlackCalibrationData;
+                default:
+                    return null;
+            }
+        }
+        private PMR.ColorLab.LiquidType ConvertLiquidTypeToPMR(BL.Entities.LiquidType liquidType)
+        {
+            if (liquidType.Type == LiquidTypes.Cyan)
+                return PMR.ColorLab.LiquidType.Cyan;
+            if (liquidType.Type == LiquidTypes.Yellow)
+                return PMR.ColorLab.LiquidType.Yellow;
+            if (liquidType.Type == LiquidTypes.Magenta)
+                return PMR.ColorLab.LiquidType.Magenta;
+            return PMR.ColorLab.LiquidType.Black;
+        }
+
+        private void UpdatePlots( CalibrationPlotModel plot, List<ColorLinearizationModel.LinearizationDataItem> items, List<double> calibrationPoints)
+        {
+            plot.InitDataGraph(items);
+            plot.InitLinearizationGraph(items, calibrationPoints);
+        }
+
+        private  void LoadDataPlots(  List<RmlExtensionColorCalibrationsTestsLiquidDataPoint> points, CalibrationPlotModel plot, CalibrationDataVM calibrationTable)
+        {
+            List<ColorLinearizationModel.LinearizationDataItem> items = new List<ColorLinearizationModel.LinearizationDataItem>();
+            points.ForEach(x => items.Add(new ColorLinearizationModel.LinearizationDataItem() { InkPercentage = x.Ink, L = x.L, A = x.A, B = x.B }));
+            
+            List<double> calibrationPoints = new List<double>();
+
+            calibrationTable.CalibrationPoints.Clear();
+            var index = 1;
+            points.ForEach(x => {
+                calibrationTable.CalibrationPoints.Add(new CalibrationDataPointVM() { Index = index++, X = x.Ink, Y = x.CalculatedPoint });
+                calibrationPoints.Add(x.CalculatedPoint);
+            });
+            UpdatePlots(plot, items, calibrationPoints);
+        }
+
+        private void OnRmlExtensionColorCalibrationsTestChanged()
+        {
+            
+        }
+        #endregion
+
+        #region CreateLinearizationGraph
+
+        private List<double> GetLinearizationMeasurements(List<ColorLinearizationModel.LinearizationDataItem> 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..3f4d8a415
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/ColorCalibrationViewVM.cs
@@ -0,0 +1,530 @@
+
+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;
+        private List<BL.Entities.LiquidType> _liquids;
+
+        public event EventHandler SaveColorCalibration;
+
+
+        #region Properties
+
+        private ObservableCollection<ColorCalibrationTabVM> _calibrationTabs;
+
+        public ObservableCollection<ColorCalibrationTabVM> 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 RMLExtentionGUID
+        {
+            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;
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is view loaded. Used to update charts.
+        /// </summary>
+        public bool IsViewLoaded
+        {
+            get { return _isViewLoaded; }
+            set
+            {
+                if (_isViewLoaded != value)
+                {
+                    _isViewLoaded = value;
+                }
+            }
+        }
+
+        private RmlExtensionColorCalibration _rmlExtensionColorCalibration;
+
+        public RmlExtensionColorCalibration RmlExtensionColorCalibration
+        {
+            get { return _rmlExtensionColorCalibration; }
+            set { _rmlExtensionColorCalibration = value; }
+        }
+
+        //private ObservableCollection<RmlExtensionColorCalibrationsTest> _rmlExtensionColorCalibrationsTests;
+
+        //public ObservableCollection<RmlExtensionColorCalibrationsTest> RmlExtensionColorCalibrationsTests
+        //{
+        //    get { return _rmlExtensionColorCalibrationsTests; }
+        //    set { _rmlExtensionColorCalibrationsTests = 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<ColorCalibrationTabVM> RemoveTabCommand { get; set; }
+        
+        public RelayCommand RenameTabCommand { get; set; }
+        
+        #endregion
+
+        public ColorCalibrationViewVM(INotificationProvider notification, IActionLogManager actionLogManager)
+        {
+            _notification = notification;
+            _actionLogManager = actionLogManager;
+            CalibrationTabs = new ObservableCollection<ColorCalibrationTabVM>();
+
+            ApplyToRMLCommand = new RelayCommand(ApplyToRML);
+            ApplyToMachineCalibrationCommand = new RelayCommand(ApplyToMachineCalibration);
+            SaveCommand = new RelayCommand(Save, () => IsFree);
+            
+            AddTabCommand = new RelayCommand(() => AddNewTab());
+            RemoveTabCommand = new RelayCommand<ColorCalibrationTabVM>(RemoveTab);
+            RenameTabCommand = new RelayCommand(RenameTab);
+
+            CreateColorDataImportExcelTemplateCommand = new RelayCommand(CreateColorDataImportExcelTemplate);
+        }
+        
+        #region Methods
+
+        private void OnRMLExtensionGUIDChanged()
+        {
+        }
+
+        private void SelectedMachineChanged()
+        {
+            SelectedTab = null;
+            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.");
+            }
+        }
+        /// <summary>
+        /// Applies calibration points to RML.
+        /// </summary>
+        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<LiquidTypesRml> 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);
+        }
+        /// <summary>
+        /// Applies calibration points to machine calibration.
+        /// </summary>
+        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<IdsPack> 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;
+            }
+            try
+            {
+                IsFree = false;
+                if (_active_context != null)
+                {
+                    _active_context.Dispose();
+                }
+
+                _active_context = ObservablesContext.CreateDefault();
+                if (_liquids == null)
+                {
+                    _liquids = _active_context.LiquidTypes.ToList();
+                }
+                CalibrationTabs.Clear();
+                LogManager.Log("Loading color calibration tests ...");
+
+                using (_notification.PushTaskItem("Loading Color Calibrations Tests ..."))
+                {
+                    var testResults = await new RMLExtensionColorCalibrationBuilder(_active_context).SetAll().ForRMLExtension(RMLExtentionGUID).ForMachine(Machine.Guid).WithTests().BuildAsync();
+                    RmlExtensionColorCalibration = testResults.OrderBy(x => x.ID).ToList().FirstOrDefault();
+                    if (RmlExtensionColorCalibration == null)
+                    {
+                        RmlExtensionColorCalibration = new RmlExtensionColorCalibration() { RmlsExtensionsGuid = RMLExtentionGUID, MachineGuid = Machine.Guid };
+                        _active_context.RmlExtensionColorCalibrations.Add(RmlExtensionColorCalibration);
+                        _active_context.SaveChanges();
+                    }
+
+                    foreach (var test in RmlExtensionColorCalibration.RmlExtensionColorCalibrationsTests)
+                    {
+                        CalibrationTabs.Add(new ColorCalibrationTabVM(_notification, _actionLogManager, _liquids) { RmlExtensionColorCalibrationsTest = test, Name = test.Name });
+                        if (CalibrationTabs.Count == 1)
+                            SelectedTab = CalibrationTabs[0];
+                    }
+                    if (CalibrationTabs.Count == 0)
+                    {
+                        SelectedTab = CreateNewColorCalibrationTabVM("Untitled", 1);
+                        CalibrationTabs.Add(SelectedTab);
+                        _active_context.SaveChanges();
+                    }
+                    if (IsViewLoaded)
+                    {
+                        CalibrationTabs.ToList().ForEach(x => x.InitData());
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                LogManager.Log(ex, $"Error loading Color Calibration tests.\n{ex.FlattenMessage()}");
+            }
+            finally
+            {
+                IsFree = true;
+            }
+        }
+        
+        private ColorCalibrationTabVM CreateNewColorCalibrationTabVM(string name, int index)
+        {
+            ColorCalibrationTabVM newtab = new ColorCalibrationTabVM(_notification, _actionLogManager, _liquids) { Name = name, TabIndex = index };
+
+            newtab.RmlExtensionColorCalibrationsTest = new RmlExtensionColorCalibrationsTest()
+            {
+                RmlExtensionColorCalibrationGuid = RmlExtensionColorCalibration.Guid,
+                Name = name
+            };
+            var liquidDataCollection = new SynchronizedObservableCollection<RmlExtensionColorCalibrationsTestsLiquidData>();
+            var liquidtype = _liquids.Where(l => l.Type == LiquidTypes.Cyan).FirstOrDefault();
+            var l_guid = liquidtype.Guid;
+            liquidDataCollection.Add(new RmlExtensionColorCalibrationsTestsLiquidData() { RmlExtensionColorCalibrationsTestGuid = newtab.RmlExtensionColorCalibrationsTest.Guid, LiquidTypeGuid = l_guid });
+            liquidtype = _liquids.Where(l => l.Type == LiquidTypes.Magenta).FirstOrDefault();
+            l_guid = liquidtype.Guid;
+            liquidDataCollection.Add(new RmlExtensionColorCalibrationsTestsLiquidData() { RmlExtensionColorCalibrationsTestGuid = newtab.RmlExtensionColorCalibrationsTest.Guid, LiquidTypeGuid = l_guid});
+            liquidtype = _liquids.Where(l => l.Type == LiquidTypes.Yellow).FirstOrDefault();
+            l_guid = liquidtype.Guid;
+            liquidDataCollection.Add(new RmlExtensionColorCalibrationsTestsLiquidData() { RmlExtensionColorCalibrationsTestGuid = newtab.RmlExtensionColorCalibrationsTest.Guid, LiquidTypeGuid = l_guid });
+            liquidtype = _liquids.Where(l => l.Type == LiquidTypes.Black).FirstOrDefault();
+            l_guid = liquidtype.Guid;
+            liquidDataCollection.Add(new RmlExtensionColorCalibrationsTestsLiquidData() { RmlExtensionColorCalibrationsTestGuid = newtab.RmlExtensionColorCalibrationsTest.Guid, LiquidTypeGuid = l_guid });
+            newtab.RmlExtensionColorCalibrationsTest.RmlExtensionColorCalibrationsTestsLiquidData = liquidDataCollection;
+            if(RmlExtensionColorCalibration != null)
+            {
+                RmlExtensionColorCalibration.RmlExtensionColorCalibrationsTests.Add(newtab.RmlExtensionColorCalibrationsTest);
+               // _active_context.RmlExtensionColorCalibrations.Add(RmlExtensionColorCalibration);
+            }
+                
+            return newtab;
+        }
+
+        #endregion
+
+        #region Tabs modification
+
+        /// <summary>
+        /// Removes the specified tab.
+        /// </summary>
+        /// <param name="tab">The tab.</param>
+        private void RemoveTab(ColorCalibrationTabVM tab)
+        {
+            if (CalibrationTabs.Count == 1)
+                return;
+            if (_notification.ShowQuestion("Are you sure you want to delete the selected tab?"))
+            {
+                foreach( var liquidData in tab.RmlExtensionColorCalibrationsTest.RmlExtensionColorCalibrationsTestsLiquidData)
+                {
+
+                    _active_context.RmlExtensionColorCalibrationsTestsLiquidDataPoints.RemoveRange(liquidData.RmlExtensionColorCalibrationsTestsLiquidDataPoints);
+                }
+                _active_context.RmlExtensionColorCalibrationsTestsLiquidData.RemoveRange(tab.RmlExtensionColorCalibrationsTest.RmlExtensionColorCalibrationsTestsLiquidData);
+                tab.RmlExtensionColorCalibrationsTest.RmlExtensionColorCalibrationsTestsLiquidData = null;
+
+                RmlExtensionColorCalibration.RmlExtensionColorCalibrationsTests.Remove(tab.RmlExtensionColorCalibrationsTest);
+                _active_context.RmlExtensionColorCalibrationsTests.Remove(tab.RmlExtensionColorCalibrationsTest);
+
+                CalibrationTabs.Remove(tab);
+                SelectedTab = CalibrationTabs.LastOrDefault();
+                _active_context.SaveChanges();
+            }
+        }
+
+        /// <summary>
+        /// Adds a new tab.
+        /// </summary>
+        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));
+               _active_context.SaveChanges();
+                CalibrationTabs.Add(tab);
+                SelectedTab = tab;
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Renames the tab.
+        /// </summary>
+        /// <param name="tab">The tab.</param>
+        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;
+                DateTime lastUpdated = DateTime.UtcNow;
+                RmlExtensionColorCalibration.LastUpdated = lastUpdated;
+
+                foreach (var tab in CalibrationTabs)
+                {
+                    tab.RmlExtensionColorCalibrationsTest.LastUpdated = lastUpdated;
+                    var removedPoints = tab.RemovedPoints;
+                    foreach (var liquidData in tab.RmlExtensionColorCalibrationsTest.RmlExtensionColorCalibrationsTestsLiquidData)
+                    {
+                        var liquidtype = _liquids.Where(l => l.Guid == liquidData.LiquidTypeGuid).FirstOrDefault();
+                        if (liquidtype != null && removedPoints.ContainsKey(liquidtype.Type))
+                        {
+                            _active_context.RmlExtensionColorCalibrationsTestsLiquidDataPoints.RemoveRange(removedPoints[liquidtype.Type]);
+                        }
+                        liquidData.LastUpdated = lastUpdated;
+                    }
+                    tab.RemovedPoints.Clear();
+                }
+                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/ColorShadeTabVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/ColorShadeTabVM.cs
new file mode 100644
index 000000000..eaaf7dc96
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/ColorShadeTabVM.cs
@@ -0,0 +1,129 @@
+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.BL.ActionLogs;
+using Tango.BL.Entities;
+using Tango.Core;
+
+namespace Tango.MachineStudio.ThreadExtensions.ViewModels
+{
+    public class ColorShadeTabVM : ViewModel
+    {
+        private INotificationProvider _notification;
+        private IActionLogManager _actionLogManager;
+
+        #region Properties
+
+        private string _name;
+        /// <summary>
+        /// Gets or sets the name of the thread. Using in print
+        /// </summary>
+        public string Name
+        {
+            get { return _name; }
+            set
+            {
+                _name = value;
+                if (RmlExtensionColorShadesTest != null)
+                    RmlExtensionColorShadesTest.Name = _name;
+                RaisePropertyChangedAuto();
+            }
+        }
+
+        private int _tabIndex;
+
+        public int TabIndex
+        {
+            get { return _tabIndex; }
+            set
+            {
+                _tabIndex = value;
+                RaisePropertyChangedAuto();
+            }
+        }
+
+
+        private bool _isSelected;
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is selected.
+        /// </summary>
+        public bool IsSelected
+        {
+            get { return _isSelected; }
+            set { _isSelected = value; RaisePropertyChangedAuto(); }
+        }
+
+        private RmlExtensionColorShadesTest _rmlExtensionColorShadesTest;
+
+        public RmlExtensionColorShadesTest RmlExtensionColorShadesTest
+        {
+            get { return _rmlExtensionColorShadesTest; }
+            set
+            {
+                _rmlExtensionColorShadesTest = value;
+                RaisePropertyChangedAuto();
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets last points before save. Used in Save to remove points before save new.
+        /// </summary>
+        /// <value>
+        /// The removed points.
+        /// </value>
+        public  List<RmlExtensionColorShadesTestsData> RemovedDataList { get; set; }
+
+        #endregion
+
+        public RelayCommand ImportColorsCommand { get; set; }
+
+        public ColorShadeTabVM(INotificationProvider notification, IActionLogManager actionLogManager)
+        {
+            _notification = notification;
+            _actionLogManager = actionLogManager;
+            ImportColorsCommand = new RelayCommand(ImportColors);
+            RemovedDataList = new List<RmlExtensionColorShadesTestsData>();
+        }
+
+        private void ImportColors(object obj)
+        {
+            List<ColorShadesModel.ColorShadesDataItem> items;
+
+            OpenFileDialog dlg = new OpenFileDialog();
+            dlg.Title = "Select data file";
+            dlg.Filter = "Excel |*.xlsx";
+            items = null;
+            if (dlg.ShowDialogCenter() && dlg.FileName.IsNotNullOrEmpty())
+            {
+                ColorShadesModel model = new ColorShadesModel();
+                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.");
+
+                }
+                else
+                {
+                    if (RemovedDataList.Count == 0 && RmlExtensionColorShadesTest.RmlExtensionColorShadesTestsData.Count > 0)
+                    {
+                        RemovedDataList = new List<RmlExtensionColorShadesTestsData>(RmlExtensionColorShadesTest.RmlExtensionColorShadesTestsData.ToList());
+                    }
+                    RmlExtensionColorShadesTest.RmlExtensionColorShadesTestsData.Clear();
+                    items.ForEach(x => RmlExtensionColorShadesTest.RmlExtensionColorShadesTestsData.Add(new RmlExtensionColorShadesTestsData() {
+                        ColorNum = x.ColorNumber, L = x.L, A = x.A, B = x.B, C = x.C, M = x.M, Y = x.Y, K = x.K, Ti = x.TI, LRes = x.L2, ARes = x.A2, BRes = x.B2, DeltaE = x.DelteE }));
+                    
+                }
+               
+            }
+        }
+    }
+}
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/ColorShadeViewVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/ColorShadeViewVM.cs
new file mode 100644
index 000000000..f305d5139
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/ColorShadeViewVM.cs
@@ -0,0 +1,400 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+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.MachineStudio.ThreadExtensions.ViewModels;
+using System.Collections.ObjectModel;
+using Tango.BL.Calibration;
+
+namespace Tango.MachineStudio.ThreadExtensions.ViewModels
+{
+    public class ColorShadeViewVM : ViewModel
+    {
+        private INotificationProvider _notification;
+        private IActionLogManager _actionLogManager;
+
+        private ObservablesContext _active_context;
+        public event EventHandler SaveColorShadesEvent;
+
+        #region Properties
+
+        
+        private RmlExtensionColorShade _colorShade;
+
+        public RmlExtensionColorShade RmlExtensionColorShade
+        {
+            get { return _colorShade; }
+            set { _colorShade = value;
+                RaisePropertyChangedAuto();
+            }
+        }
+        
+        private ObservableCollection<ColorShadeTabVM> _colorShadeTabs;
+
+        public ObservableCollection<ColorShadeTabVM> ColorShadeTabs
+        {
+            get { return _colorShadeTabs; }
+            set { _colorShadeTabs = value; }
+        }
+
+        private ColorShadeTabVM _selectedTab;
+
+        public ColorShadeTabVM SelectedTab
+        {
+            get { return _selectedTab; }
+            set
+            {
+                _selectedTab = value;
+                RaisePropertyChangedAuto();
+
+                foreach (var tab in _colorShadeTabs.Where(x => x != _selectedTab))
+                {
+                    tab.IsSelected = false;
+                }
+
+                if (_selectedTab != null)
+                {
+                    _selectedTab.IsSelected = true;
+                }
+            }
+        }
+
+        private string _RMLExtentionGUID;
+
+        public string RMLExtentionGUID
+        {
+            get { return _RMLExtentionGUID; }
+            set
+            {
+                _RMLExtentionGUID = value;
+            }
+        }
+
+        private string _RMLGUID;
+
+        public string RMLGUID
+        {
+            get { return _RMLGUID; }
+            set
+            {
+                _RMLGUID = value;
+            }
+        }
+
+        protected string _selectedMachineGuid;
+        /// <summary>
+        /// Gets or sets the selected machine.
+        /// </summary>
+        public String SelectedMachineGUID
+        {
+            get { return _selectedMachineGuid; }
+            set
+            {
+                if (value != null && _selectedMachineGuid != value)
+                {
+                    _selectedMachineGuid = value;
+                    SelectedMachineChanged();
+                    RaisePropertyChangedAuto();
+                    InvalidateRelayCommands();
+                }
+            }
+        }
+
+
+        private bool _isViewLoaded;
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is view loaded. Used to update charts.
+        /// </summary>
+        public bool IsViewLoaded
+        {
+            get { return _isViewLoaded; }
+            set
+            {
+                if (_isViewLoaded != value)
+                {
+                    _isViewLoaded = value;
+                }
+            }
+        }
+
+        #endregion
+
+        #region commands
+        public RelayCommand CreateColorDataImportExcelTemplateCommand { get; set; }
+       
+        public RelayCommand SaveCommand { get; set; }
+
+        public RelayCommand AddTabCommand { get; set; }
+
+        public RelayCommand<ColorShadeTabVM> RemoveTabCommand { get; set; }
+
+        public RelayCommand RenameTabCommand { get; set; }
+
+        #endregion
+
+        public ColorShadeViewVM(INotificationProvider notification, IActionLogManager actionLogManager)
+        {
+            _notification = notification;
+            _actionLogManager = actionLogManager;
+            ColorShadeTabs = new ObservableCollection<ColorShadeTabVM>();
+
+            SaveCommand = new RelayCommand(Save, () => IsFree);
+
+            AddTabCommand = new RelayCommand(() => AddNewTab());
+            RemoveTabCommand = new RelayCommand<ColorShadeTabVM>(RemoveTab);
+            RenameTabCommand = new RelayCommand(RenameTab);
+
+            CreateColorDataImportExcelTemplateCommand = new RelayCommand(CreateColorDataImportExcelTemplate);
+        }
+
+        #region Loading
+        public async void LoadColorShades()
+        {
+            if (SelectedMachineGUID == null)
+            {
+                _notification.ShowWarning(LogManager.Log($"Please, select machine.", LogCategory.Warning));
+                IsFree = false;
+                return;
+            }
+            if (RMLGUID == null)
+            {
+                IsFree = false;
+                return;
+            }
+            try
+            {
+                IsFree = false;
+                if (_active_context != null)
+                {
+                    _active_context.Dispose();
+                }
+
+                _active_context = ObservablesContext.CreateDefault();
+
+                ColorShadeTabs.Clear();
+                LogManager.Log("Loading color shade view ...");
+                using (_notification.PushTaskItem("Loading Color Shade View ..."))
+                {
+                    var testResults = await new RMLExtensionColorShadeBuilder(_active_context).SetAll().ForRMLExtension(RMLExtentionGUID).ForMachine(SelectedMachineGUID).WithTests().BuildAsync();
+                    RmlExtensionColorShade = testResults.OrderBy(x => x.ID).ToList().FirstOrDefault();
+                    if (RmlExtensionColorShade == null)
+                    {
+                        RmlExtensionColorShade = new RmlExtensionColorShade() { RmlsExtensionsGuid = RMLExtentionGUID, MachineGuid = SelectedMachineGUID };
+                        _active_context.RmlExtensionColorShades.Add(RmlExtensionColorShade);
+                        _active_context.SaveChanges();
+                    }
+
+                    foreach (var test in RmlExtensionColorShade.RmlExtensionColorShadesTests)
+                    {
+                        ColorShadeTabs.Add(new ColorShadeTabVM(_notification, _actionLogManager) { RmlExtensionColorShadesTest = test, Name = test.Name });
+                        if (ColorShadeTabs.Count == 1)
+                            SelectedTab = ColorShadeTabs[0];
+                    }
+                    if (ColorShadeTabs.Count == 0)
+                    {
+                        SelectedTab = CreateNewColorShadeTabVM("Untitled", 1);
+                        ColorShadeTabs.Add(SelectedTab);
+                        _active_context.SaveChanges();
+                    }
+                    if (IsViewLoaded)
+                    {
+                    //    ColorShadeTabs.ToList().ForEach(x => x.InitData());
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                LogManager.Log(ex, $"Error loading Color Calibration tests.\n{ex.FlattenMessage()}");
+            }
+            finally
+            {
+                IsFree = true;
+            }
+        }
+
+        private ColorShadeTabVM CreateNewColorShadeTabVM(string name, int index)
+        {
+            ColorShadeTabVM newtab = new ColorShadeTabVM(_notification, _actionLogManager) { Name = name, TabIndex = index };
+
+            newtab.RmlExtensionColorShadesTest = new RmlExtensionColorShadesTest()
+            {
+                RmlExtensionColorShadesGuid = RmlExtensionColorShade.Guid,
+                Name = name
+            };
+            if (RmlExtensionColorShade != null)
+            {
+                RmlExtensionColorShade.RmlExtensionColorShadesTests.Add(newtab.RmlExtensionColorShadesTest);
+            }
+            
+            return newtab;
+        }
+        #endregion
+
+        #region Methods
+
+        private void OnRMLExtensionGUIDChanged()
+        {
+        }
+
+        private void SelectedMachineChanged()
+        {
+            SelectedTab = null;
+            LoadColorShades();
+        }
+
+        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 Shades File Template";
+                if (dlg.ShowDialog().Value)
+                {
+                    CalibrationHelper.CreateColorShadesInputExcelTemplate(dlg.FileName);
+                }
+            }
+            catch (Exception ex)
+            {
+                LogManager.Log(ex, "Error generating excel color shades template file " + dlg.FileName);
+                _notification.ShowError("An error occurred while trying to generate the color shades file.");
+            }
+        }
+
+        #endregion
+
+        #region Tabs modification
+
+        /// <summary>
+        /// Removes the specified tab.
+        /// </summary>
+        /// <param name="tab">The tab.</param>
+        private void RemoveTab(ColorShadeTabVM tab)
+        {
+            if (ColorShadeTabs.Count == 1)
+                return;
+            if (_notification.ShowQuestion("Are you sure you want to delete the selected tab?"))
+            {
+                _active_context.RmlExtensionColorShadesTestsData.RemoveRange(tab.RmlExtensionColorShadesTest.RmlExtensionColorShadesTestsData.ToList());
+                
+                //_active_context.RmlExtensionColorCalibrationsTestsLiquidData.RemoveRange(tab.RmlExtensionColorCalibrationsTest.RmlExtensionColorCalibrationsTestsLiquidData);
+                tab.RmlExtensionColorShadesTest.RmlExtensionColorShadesTestsData = null;
+
+                RmlExtensionColorShade.RmlExtensionColorShadesTests.Remove(tab.RmlExtensionColorShadesTest);
+                _active_context.RmlExtensionColorShadesTests.Remove(tab.RmlExtensionColorShadesTest);
+
+                ColorShadeTabs.Remove(tab);
+                SelectedTab = ColorShadeTabs.LastOrDefault();
+                _active_context.SaveChanges();
+            }
+        }
+
+        /// <summary>
+        /// Adds a new tab.
+        /// </summary>
+        private bool AddNewTab(String name = null)
+        {
+            if (ColorShadeTabs.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 = CreateNewColorShadeTabVM(name, (ColorShadeTabs.Count + 1));
+                _active_context.SaveChanges();
+                ColorShadeTabs.Add(tab);
+                SelectedTab = tab;
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Renames the tab.
+        /// </summary>
+        /// <param name="tab">The tab.</param>
+        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 (SelectedMachineGUID == null)
+            {
+                _notification.ShowWarning(LogManager.Log($"Could not save Color Shades. Please, select machine before save.", LogCategory.Warning));
+                return;
+            }
+
+            try
+            {
+                IsFree = false;
+                DateTime lastUpdated = DateTime.UtcNow;
+                RmlExtensionColorShade.LastUpdated = lastUpdated;
+
+                foreach (var tab in ColorShadeTabs)
+                {
+                    tab.RmlExtensionColorShadesTest.LastUpdated = lastUpdated;
+                    var removedPoints = tab.RemovedDataList;
+                    if (removedPoints.Count > 0)
+                    {
+                        _active_context.RmlExtensionColorShadesTestsData.RemoveRange(removedPoints);
+                     }
+                    tab.RemovedDataList.Clear();
+                }
+                await _active_context.SaveChangesAsync();
+                
+            }
+            catch (Exception ex)
+            {
+                LogManager.Log(ex, "Could not update color shades.");
+                _notification.ShowError($"An error occurred while trying to save color shades.\n{ex.Message}");
+            }
+            finally
+            {
+                IsFree = true;
+                EventHandler handler = SaveColorShadesEvent;
+                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..47965deb4 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,21 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels
             set { _testResultsViewVM = value; RaisePropertyChangedAuto(); }
         }
 
+        private ColorCalibrationViewVM _colorCalibrationViewVM;
+        public ColorCalibrationViewVM ColorCalibrationViewVM
+        {
+            get { return _colorCalibrationViewVM; }
+            set { _colorCalibrationViewVM = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ColorShadeViewVM _solorShadeViewVM;
+        public ColorShadeViewVM ColorShadeViewVM
+        {
+            get { return _solorShadeViewVM; }
+            set { _solorShadeViewVM = value; RaisePropertyChangedAuto(); }
+        }
+       
+
         protected MachineModel _selectedMachine;
         /// <summary>
         /// Gets or sets the selected machine.
@@ -294,20 +309,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 +937,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 +1010,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 +1054,27 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels
                     TestResultsViewVM.SelectedMachineGUID = SelectedMachine != null ? SelectedMachine.Guid : null;
                     TestResultsViewVM.ThreadName = ActiveRML.Manufacturer;
 
+                    ColorCalibrationViewVM = new ColorCalibrationViewVM(_notification, _actionLogManager);
+                    ColorCalibrationViewVM.RMLExtentionGUID = guid;
+                    ColorCalibrationViewVM.ActiveRML = ActiveRML;
+                    ColorCalibrationViewVM.RMLGUID = ActiveRML.Guid;
+                    ColorCalibrationViewVM.Machine = SelectedMachine;
+
+                    ColorShadeViewVM = new ColorShadeViewVM(_notification, _actionLogManager);
+                    ColorShadeViewVM.RMLExtentionGUID = guid;
+                    ColorShadeViewVM.RMLGUID = ActiveRML.Guid;
+                    ColorShadeViewVM.SelectedMachineGUID = SelectedMachine != null ? SelectedMachine.Guid : null; ;
+                    
                     if (ActiveRMLExtension.RMLStatus == RMLExtensionStatus.New)
                     {
                         ColorParametersVewVM.SaveColorParameters -= UpdateStatus;
                         ColorParametersVewVM.SaveColorParameters += UpdateStatus;
                         TestResultsViewVM.SaveTestResults -= UpdateStatus;
                         TestResultsViewVM.SaveTestResults += UpdateStatus;
+                        ColorCalibrationViewVM.SaveColorCalibration -= UpdateStatus;
+                        ColorCalibrationViewVM.SaveColorCalibration += UpdateStatus;
+                        ColorShadeViewVM.SaveColorShadesEvent -= UpdateStatus;
+                        ColorShadeViewVM.SaveColorShadesEvent += UpdateStatus;
                     }
 
                     View.NavigateTo(RMLExtensionNavigationView.RMLExtentionView);
@@ -1108,6 +1137,8 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels
             {
                 ColorParametersVewVM.SaveColorParameters -= UpdateStatus;
                 TestResultsViewVM.SaveTestResults -= UpdateStatus;
+                ColorCalibrationViewVM.SaveColorCalibration -= UpdateStatus;
+                ColorShadeViewVM.SaveColorShadesEvent -= UpdateStatus;
                 ActiveRMLExtension.RMLStatus = RMLExtensionStatus.InProgress;
                 ActiveRMLExtension.LastUpdated = DateTime.UtcNow;
 
@@ -1134,6 +1165,14 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels
             {
                 TestResultsViewVM.SelectedMachineGUID = SelectedMachine.Guid;
             }
+            if(ColorCalibrationViewVM != null)
+            {
+                ColorCalibrationViewVM.Machine = SelectedMachine;
+            }
+            if(ColorShadeViewVM != null)
+            {
+                ColorShadeViewVM.SelectedMachineGUID = SelectedMachine.Guid;
+            }
         }
 
         #endregion
@@ -1183,10 +1222,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 +1233,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 +1343,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/ViewModels/TestResultViewVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/TestResultViewVM.cs
index 41be789ed..68a886f99 100644
--- a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/TestResultViewVM.cs
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/TestResultViewVM.cs
@@ -1,8 +1,11 @@
 using Microsoft.Win32;
+using Microsoft.WindowsAPICodePack.Dialogs;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Data.Entity;
+using System.Diagnostics;
 using System.Text;
 using System.Threading.Tasks;
 using Tango.BL;
@@ -10,6 +13,7 @@ using Tango.BL.ActionLogs;
 using Tango.BL.DTO;
 using Tango.BL.Entities;
 using Tango.BL.Enumerations;
+using Tango.BL.ValueObjects;
 using Tango.Core.Commands;
 using Tango.MachineStudio.Common.Notifications;
 using Tango.MachineStudio.ThreadExtensions.Models;
@@ -21,9 +25,9 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels
     {
         private INotificationProvider _notification;
         private IActionLogManager _actionLogManager;
-        
+
         #region Properties
-        
+
         private string _threadName;
         /// <summary>
         /// Gets or sets the name of the thread. Using in print
@@ -51,7 +55,7 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels
             get { return _isSelected; }
             set { _isSelected = value; RaisePropertyChangedAuto(); }
         }
-        
+
         private RmlExtensionTestResult _testResult;
 
         public RmlExtensionTestResult TestResult
@@ -59,19 +63,124 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels
             get { return _testResult; }
             set { _testResult = value;
                 RaisePropertyChangedAuto();
+                RaisePropertyChanged(nameof(TestResultsFiles));
             }
         }
 
-
-        #endregion
+        public List<RmlExtensionTestResultsFile> TestResultsFiles
+        {
+            get
+            {
+                return TestResult.RmlExtensionTestResultsFiles.ToList();
+            }
+        }
         
+        public RelayCommand<RmlExtensionTestResultsFile> DeleteCommand { get; set; }
+        public RelayCommand<RmlExtensionTestResultsFile> DownLoadFileCommand { get; set; }
+        public RelayCommand UploadCommand { get; set; }
+        public RelayCommand DownLoadAllCommand { get; set; }
+        #endregion
+
 
         public TestResultViewVM(INotificationProvider notification, IActionLogManager actionLogManager)
         {
             _notification = notification;
             _actionLogManager = actionLogManager;
+            
+            UploadCommand = new RelayCommand(UploadFiles);
+            DownLoadFileCommand = new RelayCommand<RmlExtensionTestResultsFile>(DownLoadFile);
+            DeleteCommand = new RelayCommand<RmlExtensionTestResultsFile>(DeleteFile);
+            DownLoadAllCommand = new RelayCommand(DownLoadAllFiles);
         }
+
+        #region TestResultsFiles
         
+        private async void UploadFiles(object obj)
+        {
+            OpenFileDialog dlg = new OpenFileDialog();
+            dlg.Title = "Select data file";
+            dlg.Filter = "CSV Files|*.csv";
+            dlg.Multiselect = true;
+            if (dlg.ShowDialog().Value)
+            {
+                try
+                {
+                    var files = dlg.FileNames.ToList();
+
+                    using (ObservablesContext db = ObservablesContext.CreateDefault())
+                    {
+                        var testResult = await db.RmlExtensionTestResults.Where(x => x.Guid == TestResult.Guid).Include(t1 => t1.RmlExtensionTestResultsFiles).FirstOrDefaultAsync();
+                        foreach (var strpath in files)
+                        {
+                            var testResultfile = new RmlExtensionTestResultsFile();
+                            testResultfile.FileName = Path.GetFileName(strpath);
+                            //temporary!!!
+                            testResultfile.FilePath = strpath;
+                            
+                           // TestResult.RmlExtensionTestResultsFiles.Add(testResultfile);
+                            testResult.RmlExtensionTestResultsFiles.Add(testResultfile);
+                        }
+                        if (testResult != null)
+                        {
+                            await db.SaveChangesAsync();
+                        }
+                        TestResult.RmlExtensionTestResultsFiles = testResult.RmlExtensionTestResultsFiles;///?????
+                        RaisePropertyChanged(nameof(TestResultsFiles));
+                    }
+                    _notification.ShowInfo("File successfully loaded.");
+                }
+                catch (Exception ex)
+                {
+                    _notification.ShowError($"An error occurred while trying to import the file.\n{ex.FlattenMessage()}");
+                }
+            }
+           
+        }
+        
+        private void DownLoadFile(RmlExtensionTestResultsFile file)
+        {
+            SaveFileDialog dlg = new SaveFileDialog();
+            dlg.Title = "Save the csv file";
+            dlg.Filter = "CSV Files|*.csv";
+            dlg.DefaultExt = ".csv";
+            dlg.FileName = file.FileName;
+            if (dlg.ShowDialog().Value)
+            {
+                ///
+            }
+        }
+
+        private void DownLoadAllFiles()
+        {
+            CommonOpenFileDialog dlg = new CommonOpenFileDialog();
+            dlg.Title = "Select folder.";
+            dlg.IsFolderPicker = true;
+            if (dlg.ShowDialog() == CommonFileDialogResult.Ok)
+            {
+                var filesPath = TestResult.RmlExtensionTestResultsFiles.Select( x=>x.FilePath).ToList();
+                /////
+            }
+        }
+
+        private async void DeleteFile(RmlExtensionTestResultsFile file)
+        {
+            if (_notification.ShowQuestion("Are you sure you want to delete the selected file?"))
+            {
+                using (ObservablesContext db = ObservablesContext.CreateDefault())
+                {
+                    var deletefile = db.RmlExtensionTestResultsFiles.FirstOrDefault(x => x.Guid == file.Guid);
+                    if(deletefile != null)
+                    {
+                        db.RmlExtensionTestResultsFiles.Remove(deletefile);
+                        await db.SaveChangesAsync();
+                    }
+                }
+                TestResult.RmlExtensionTestResultsFiles.Remove(file);
+                RaisePropertyChanged(nameof(TestResultsFiles));
+            }
+        }
         
+        #endregion
+
     }
 }
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/TestResultsViewVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/TestResultsViewVM.cs
index c1fb4497f..f639eb6e7 100644
--- a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/TestResultsViewVM.cs
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/TestResultsViewVM.cs
@@ -1,6 +1,8 @@
-using System;
+using Microsoft.Win32;
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -271,7 +273,7 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels
 
                 using (_notification.PushTaskItem("Loading Test Results Parameters ..."))
                 {
-                    var testResults = await new RMLExtensionTestResultsCollectionBuilder(_active_context).SetAll().ForRMLExtension(RMLExtemtionGUID).ForMachine(SelectedMachineGUID).WithRubbingAndTensileResults().BuildAsync();
+                    var testResults = await new RMLExtensionTestResultsCollectionBuilder(_active_context).SetAll().ForRMLExtension(RMLExtemtionGUID).ForMachine(SelectedMachineGUID).WithRubbingAndTensileResults().WithTestResultsFiles().BuildAsync();
                     SelectedTestResults = testResults.OrderBy(x => x.ResultIndex).ToSynchronizedObservableCollection();
                     foreach (var result in SelectedTestResults)
                     {
@@ -403,6 +405,8 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels
 
         #endregion
 
+        #region  Excel
+
         public async void LoadTestResultsExcel(List<TestResultsExcelModel> testResultsExcelModelList, string machineGUID, string machineSerialNumber)
         {
             try
@@ -556,5 +560,8 @@ namespace Tango.MachineStudio.ThreadExtensions.ViewModels
                 IsFree = true;
             }
         }
+
+        #endregion
+        
     }
 }
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..407ad2e9f
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/ColorCalibrationView.xaml
@@ -0,0 +1,349 @@
+<UserControl x:Class="Tango.MachineStudio.ThreadExtensions.Views.ColorCalibrationView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             xmlns:local="clr-namespace:Tango.MachineStudio.ThreadExtensions.Views"
+             xmlns:converters="clr-namespace:Tango.SharedUI.Converters;assembly=Tango.SharedUI"
+             xmlns:enumerators="clr-namespace:Tango.BL.Enumerations;assembly=Tango.BL"
+             xmlns:global="clr-namespace:Tango.MachineStudio.ThreadExtensions"
+             xmlns:mahapps="http://metro.mahapps.com/winfx/xaml/controls"
+             xmlns:autoCompleteMachine="clr-namespace:Tango.MachineStudio.Common.AutoComplete;assembly=Tango.MachineStudio.Common"
+             xmlns:autoComplete="clr-namespace:Tango.AutoComplete.Editors;assembly=Tango.AutoComplete"
+             xmlns:oxy="http://oxyplot.org/wpf"
+             xmlns:materialDesign="http://materialdesigninxaml.net/winfx/xaml/themes"
+             xmlns:vm="clr-namespace:Tango.MachineStudio.ThreadExtensions.ViewModels"
+              xmlns:fa="http://schemas.fontawesome.io/icons/"
+             
+             mc:Ignorable="d" 
+             d:DesignHeight="450" d:DesignWidth="800" d:DataContext="{d:DesignInstance Type=vm:ColorCalibrationViewVM, IsDesignTimeCreatable=False}" FontSize="16">
+    <UserControl.Resources>
+        <autoCompleteMachine:MachinesProvider x:Key="MachinesProvider" />
+        <converters:EnumToDescriptionConverter x:Key="EnumToDescriptionConverter" />
+        <Style x:Key="CellNumericUpDown" TargetType="{x:Type  mahapps:NumericUpDown}" BasedOn="{StaticResource {x:Type mahapps:NumericUpDown}}">
+            <Setter Property="FrameworkElement.HorizontalAlignment" Value="Stretch"/>
+            <Setter Property="HorizontalContentAlignment" Value="Left"/>
+            <Setter Property="Background" Value="Transparent"/>
+            <Setter Property="BorderThickness" Value="0"/>
+            <Setter Property="ScrollViewer.HorizontalScrollBarVisibility" Value="Disabled"/>
+            <Setter Property="ScrollViewer.VerticalScrollBarVisibility" Value="Disabled"/>
+            <Setter Property="Focusable" Value="false"/>
+            <Setter Property="IsHitTestVisible" Value="false"/>
+            <Setter Property="ScrollViewer.VerticalScrollBarVisibility" Value="Disabled"/>
+            <Setter Property="FrameworkElement.VerticalAlignment" Value="Top"/>
+            <Setter Property="VerticalContentAlignment" Value="Center"/>
+            <Setter Property="FrameworkElement.MinHeight" Value="0"/>
+            <Setter Property="HideUpDownButtons" Value="true"/>
+            <Setter Property="FontSize" Value="14"/>
+        </Style>
+
+        <Style x:Key="EditableCellNumericUpDown" TargetType="{x:Type  mahapps:NumericUpDown}" BasedOn="{StaticResource {x:Type mahapps:NumericUpDown}}">
+            <Setter Property="FrameworkElement.HorizontalAlignment" Value="Stretch"/>
+            <Setter Property="HorizontalContentAlignment" Value="Left"/>
+            <Setter Property="BorderThickness" Value="0"/>
+            <Setter Property="ScrollViewer.HorizontalScrollBarVisibility" Value="Disabled"/>
+            <Setter Property="ScrollViewer.VerticalScrollBarVisibility" Value="Disabled"/>
+            <Setter Property="FrameworkElement.VerticalAlignment" Value="Center"/>
+            <Setter Property="VerticalContentAlignment" Value="Center"/>
+            <Setter Property="FrameworkElement.MinHeight" Value="0"/>
+            <Setter Property="FontSize" Value="14"/>
+        </Style>
+
+        <Style TargetType="DataGridCell" BasedOn="{StaticResource {x:Type DataGridCell}}">
+            <Setter Property="BorderThickness" Value="0"/>
+            <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
+            <Setter Property="VerticalContentAlignment" Value="Center"></Setter>
+        </Style>
+
+        <DataTemplate x:Key="chartsPanel">
+            <Grid Margin="10 20 0 10">
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="1*"/>
+                    <ColumnDefinition Width="1*"/>
+                </Grid.ColumnDefinitions>
+
+                <Border  Grid.Column="0" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"  BorderThickness="0" BorderBrush="{StaticResource DarkGrayBrush}" CornerRadius="5">
+                    <oxy:Plot  TitleFontSize="14" x:Name="LABDataPlot" Margin="0 0 10 0" Background="Transparent" LegendPlacement="Inside" LegendPosition="TopRight" LegendOrientation="Vertical" LegendFontSize="9" LegendItemAlignment="Left" LegendLineSpacing="3" Foreground="{StaticResource Dialog.Foreground}">
+                        <oxy:Plot.Series >
+                            <oxy:LineSeries ItemsSource="{Binding LPoints}"  Color="LawnGreen" Title="L" StrokeThickness="1.5" MarkerType="Circle" MarkerFill="LawnGreen"/>
+                            <oxy:LineSeries ItemsSource="{Binding APoints}"  Color="#E14141" Title="A" StrokeThickness="1.5" MarkerType="Circle" MarkerFill="#E14141"/>
+                            <oxy:LineSeries ItemsSource="{Binding BPoints}"  Color="#73B6EC" Title="B" StrokeThickness="1.5" MarkerType="Circle" MarkerFill="#73B6EC"/>
+                        </oxy:Plot.Series>
+                        <oxy:Plot.Axes>
+                            <oxy:LinearAxis Position="Bottom"  Title = "Ink%" MajorGridlineStyle="Solid" MinorGridlineStyle="Dot" IsZoomEnabled="True" AxisTitleDistance ="12" Minimum="0" Maximum="{Binding MaxX}" />
+                            <oxy:LinearAxis Position="Left"  Title = "LAB" MajorGridlineStyle="Solid" MinorGridlineStyle="Dot" IsZoomEnabled="True" Minimum="{Binding MinY}" Maximum="{Binding MaxY}" MinorStep="10" />
+                        </oxy:Plot.Axes>
+                    </oxy:Plot>
+                </Border>
+
+                <Grid HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Grid.Column="1" Grid.Row="0" Margin="10 0 0 0">
+                    <Border  HorizontalAlignment="Stretch" VerticalAlignment="Stretch"  BorderThickness="0" BorderBrush="{StaticResource DarkGrayBrush}" CornerRadius="5">
+                        <oxy:Plot  TitleFontSize="14" x:Name="LinearizationPlot" Margin="0 0 0 0" Background="Transparent" LegendPlacement="Inside" LegendPosition="RightTop" LegendOrientation="Vertical" >
+                            <oxy:Plot.Series >
+                                <oxy:LineSeries ItemsSource="{Binding LinearizationPoints}"  Color="#73B6EC" MarkerFill="SteelBlue" MarkerType="Circle"/>
+                            </oxy:Plot.Series>
+                            <oxy:Plot.Axes>
+                                <oxy:LinearAxis Position="Bottom"  Title = "In Ink" MajorGridlineStyle="Solid" MinorGridlineStyle="Dot" IsZoomEnabled="True" Minimum="0" Maximum="{Binding LinearizationMaxX}"/>
+                                <oxy:LinearAxis Position="Left"  Title = "Out Ink" MajorGridlineStyle="Solid" MinorGridlineStyle="Dot" IsZoomEnabled="True" Minimum="0" Maximum="{Binding LinearizationMaxY}"/>
+                            </oxy:Plot.Axes>
+                        </oxy:Plot>
+                    </Border>
+                </Grid>
+            </Grid>
+        </DataTemplate>
+
+        <DataTemplate x:Key="calibrationDataGrid">
+            <DockPanel Width="240" Margin="20 28 0 60">
+                <Grid >
+                    <DataGrid Background="{StaticResource TransparentBackgroundBrush400}" AlternatingRowBackground="{StaticResource Transparent200}" BorderThickness="1" BorderBrush="{StaticResource DarkGrayBrush}" Margin="0 0" ItemsSource="{Binding CalibrationPoints}" CanUserResizeColumns="False" CanUserReorderColumns="False" AutoGenerateColumns="False" CanUserAddRows="False" CanUserDeleteRows="True" CanUserSortColumns="False">
+                        <DataGrid.CellStyle>
+                            <Style TargetType="DataGridCell" BasedOn="{StaticResource {x:Type DataGridCell}}">
+                                <Setter Property="BorderThickness" Value="0"/>
+                                <Setter Property="HorizontalContentAlignment" Value="Left"></Setter>
+                                <Setter Property="HorizontalAlignment" Value="Stretch"></Setter>
+                                <Setter Property="Foreground" Value="{StaticResource BlackForegroundBrush}"></Setter>
+                            </Style>
+                        </DataGrid.CellStyle>
+                        <DataGrid.Resources>
+                            <Style x:Key="CellNumericUpDown" TargetType="{x:Type  mahapps:NumericUpDown}" BasedOn="{StaticResource {x:Type mahapps:NumericUpDown}}">
+                                <Setter Property="FrameworkElement.HorizontalAlignment" Value="Stretch"/>
+                                <Setter Property="HorizontalContentAlignment" Value="Left"/>
+                                <Setter Property="Background" Value="Transparent"/>
+                                <Setter Property="BorderThickness" Value="0"/>
+                                <Setter Property="ScrollViewer.HorizontalScrollBarVisibility" Value="Disabled"/>
+                                <Setter Property="ScrollViewer.VerticalScrollBarVisibility" Value="Disabled"/>
+                                <Setter Property="Focusable" Value="false"/>
+                                <Setter Property="IsHitTestVisible" Value="false"/>
+                                <Setter Property="ScrollViewer.VerticalScrollBarVisibility" Value="Disabled"/>
+                                <Setter Property="FrameworkElement.VerticalAlignment" Value="Top"/>
+                                <Setter Property="VerticalContentAlignment" Value="Center"/>
+                                <Setter Property="FrameworkElement.MinHeight" Value="0"/>
+                                <Setter Property="HideUpDownButtons" Value="true"/>
+                            </Style>
+                            <Style x:Key="EditableCellNumericUpDown" TargetType="{x:Type  mahapps:NumericUpDown}" BasedOn="{StaticResource {x:Type mahapps:NumericUpDown}}">
+                                <Setter Property="FrameworkElement.HorizontalAlignment" Value="Stretch"/>
+                                <Setter Property="HorizontalContentAlignment" Value="Left"/>
+                                <Setter Property="BorderThickness" Value="0"/>
+                                <Setter Property="ScrollViewer.HorizontalScrollBarVisibility" Value="Disabled"/>
+                                <Setter Property="ScrollViewer.VerticalScrollBarVisibility" Value="Disabled"/>
+                                <Setter Property="FrameworkElement.VerticalAlignment" Value="Top"/>
+                                <Setter Property="VerticalContentAlignment" Value="Center"/>
+                                <Setter Property="FrameworkElement.MinHeight" Value="0"/>
+                            </Style>
+                        </DataGrid.Resources>
+                        <DataGrid.Columns>
+                            <DataGridTextColumn Header="#" Binding="{Binding Index}" Width="Auto" IsReadOnly="True" Foreground="{StaticResource DimGrayBrush}" FontSize="11" />
+                            <mahapps:DataGridNumericUpDownColumn Header="X" Binding="{Binding X}" Minimum="0" Maximum="10000" HideUpDownButtons="True" Width="1*" ElementStyle="{StaticResource CellNumericUpDown}" EditingElementStyle="{StaticResource EditableCellNumericUpDown}"/>
+                            <mahapps:DataGridNumericUpDownColumn Header="Y" Binding="{Binding Y}" StringFormat="0.00" Minimum="0" Maximum="10000" HideUpDownButtons="True" Width="1*" ElementStyle="{StaticResource CellNumericUpDown}" EditingElementStyle="{StaticResource EditableCellNumericUpDown}"/>
+                        </DataGrid.Columns>
+                    </DataGrid>
+                </Grid>
+            </DockPanel>
+
+        </DataTemplate>
+    </UserControl.Resources>
+
+    <Grid x:Name="contentGrid" DataContext="{Binding  ColorCalibrationViewVM}" >
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="1*"/>
+        </Grid.RowDefinitions>
+        
+        <DockPanel Grid.Row="0">
+            <Button DockPanel.Dock="Right" HorizontalAlignment="Right" Width="170" Height="36" Margin="0 0 26 0" VerticalAlignment="Center" Command="{Binding SaveCommand}">
+                <StackPanel Orientation="Horizontal">
+                    <materialDesign:PackIcon Kind="ContentSaveAll" Width="24" Height="24" />
+                    <TextBlock VerticalAlignment="Center" Margin="10 0 0 0">SAVE</TextBlock>
+                </StackPanel>
+            </Button>
+            <Button DockPanel.Dock="Right" HorizontalAlignment="Right" Width="170" Height="36" Margin="0 0 26 0" VerticalAlignment="Center" Command="{Binding ApplyToRMLCommand}">
+                <StackPanel Orientation="Horizontal">
+                    <materialDesign:PackIcon Kind="ContentSaveAll" Width="24" Height="24" />
+                    <TextBlock VerticalAlignment="Center" Margin="10 0 0 0">Apply to RML</TextBlock>
+                </StackPanel>
+            </Button>
+            <Button DockPanel.Dock="Right" HorizontalAlignment="Right" Width="180" Height="36" Margin="0 0 26 0" VerticalAlignment="Center" Command="{Binding ApplyToMachineCalibrationCommand}" ToolTip="Apply to machine color calibration">
+                <StackPanel Orientation="Horizontal">
+                    <materialDesign:PackIcon Kind="ContentSaveAll" Width="24" Height="24" />
+                    <TextBlock VerticalAlignment="Center" Margin="10 0 0 0" Text="Apply to Machine"></TextBlock>
+                </StackPanel>
+            </Button>
+        </DockPanel>
+        <Grid Grid.Row="1" >
+            <Grid.RowDefinitions>
+                <RowDefinition Height="30"/>
+                <RowDefinition Height="1*"/>
+            </Grid.RowDefinitions>
+            <StackPanel Orientation="Horizontal" Margin="35 0 0 0">
+                <ListBox Style="{x:Null}" HorizontalAlignment="Left" HorizontalContentAlignment="Stretch" VerticalContentAlignment="Stretch" ItemContainerStyle="{StaticResource basicListBoxItem}" ScrollViewer.HorizontalScrollBarVisibility="Disabled" ScrollViewer.VerticalScrollBarVisibility="Disabled" Background="Transparent" BorderThickness="0" ItemsSource="{Binding CalibrationTabs}" SelectedItem="{Binding SelectedTab}" SelectionChanged="ListBox_SelectionChanged">
+                    <ListBox.ItemsPanel>
+                        <ItemsPanelTemplate>
+                            <StackPanel HorizontalAlignment="Left" Orientation="Horizontal"></StackPanel>
+                        </ItemsPanelTemplate>
+                    </ListBox.ItemsPanel>
+
+                    <ListBox.ItemTemplate>
+                        <DataTemplate>
+                            <Border Padding="5 5" Width="160" CornerRadius="10 10 0 0" Margin="1 0" Tag="{Binding RelativeSource={RelativeSource AncestorType=ListBox},Path=DataContext}">
+                                <Border.ContextMenu>
+                                    <ContextMenu DataContext="{Binding Path=PlacementTarget.Tag, RelativeSource={RelativeSource Self}}" Style="{x:Null}" >
+                                        <MenuItem Header="Rename" Command="{Binding RenameTabCommand}" MinWidth="210" MaxHeight="40" >
+                                            <MenuItem.Icon>
+                                                <fa:ImageAwesome Icon="Pencil" Width="16" />
+                                            </MenuItem.Icon>
+                                        </MenuItem>
+                                    </ContextMenu>
+                                </Border.ContextMenu>
+                                <Border.Style>
+                                    <Style TargetType="Border">
+                                        <Setter Property="Background" Value="{StaticResource LightGrayBrush150}"></Setter>
+                                        <Setter Property="TextElement.Foreground" Value="{StaticResource DarkGrayBrush}"></Setter>
+                                        <Style.Triggers>
+                                            <DataTrigger Binding="{Binding IsSelected}" Value="True">
+                                                <Setter Property="Background" Value="{StaticResource AccentColorBrush}"></Setter>
+                                                <Setter Property="TextElement.Foreground" Value="{StaticResource WhiteTextBrush}"></Setter>
+                                            </DataTrigger>
+                                            <Trigger Property="IsMouseOver" Value="True">
+                                                <Setter Property="Opacity" Value="0.8"></Setter>
+                                            </Trigger>
+                                        </Style.Triggers>
+                                    </Style>
+                                </Border.Style>
+                                <DockPanel VerticalAlignment="Center">
+                                    <Button Cursor="Hand" Command="{Binding RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=ListBox}, Path=DataContext.RemoveTabCommand}" CommandParameter="{Binding }" DockPanel.Dock="Right" Margin="5 0 0 0" Style="{StaticResource MaterialDesignFlatButton}" Padding="2" Height="Auto">
+                                        <materialDesign:PackIcon Kind="Close">
+                                            <materialDesign:PackIcon.Style>
+                                                <Style TargetType="materialDesign:PackIcon">
+                                                    <Setter Property="Foreground" Value="{StaticResource DarkGrayBrush}"></Setter>
+                                                    <Style.Triggers>
+                                                        <DataTrigger Binding="{Binding IsSelected}" Value="True">
+                                                            <Setter Property="Foreground" Value="{StaticResource WhiteTextBrush}"></Setter>
+                                                        </DataTrigger>
+                                                    </Style.Triggers>
+                                                </Style>
+                                            </materialDesign:PackIcon.Style>
+                                        </materialDesign:PackIcon>
+                                    </Button>
+                                    <TextBlock Text="{Binding Name}" VerticalAlignment="Center" TextAlignment="Center" TextTrimming="CharacterEllipsis" FontSize="11"></TextBlock>
+                                </DockPanel>
+                            </Border>
+                        </DataTemplate>
+                    </ListBox.ItemTemplate>
+                </ListBox>
+                <Button Margin="10 0 0 0" Style="{StaticResource MaterialDesignFlatButton}" Padding="2" Height="24" Cursor="Hand" Command="{Binding AddTabCommand}" ToolTip="New tab">
+                    <materialDesign:PackIcon Width="20" Height="20" Kind="Plus" Foreground="{StaticResource AccentColorBrush}" />
+                </Button>
+            </StackPanel>
+
+            <DockPanel Grid.Row="1" Margin="5 0 5 5">
+                <UniformGrid Columns="2" FirstColumn="0" Name="uniformGrid1" VerticalAlignment="Stretch" HorizontalAlignment="Stretch" Loaded="ContentGrid_Loaded">
+                    <DockPanel Grid.Column="0" Grid.Row="0" x:Name="CyanPanel">
+                        <Border DockPanel.Dock="Top"  Background="LightCyan" Margin="20 0 0 0 " Padding="5" CornerRadius="5" Height="40" VerticalAlignment="Top">
+                            <Border.Effect>
+                                <DropShadowEffect Opacity="0.4" />
+                            </Border.Effect>
+                            <Grid>
+                                <DockPanel>
+                                    <Button Height="Auto" DockPanel.Dock="Right" Style="{StaticResource MaterialDesignFlatButton}" Padding="0" FontSize="11" Foreground="{StaticResource DarkGrayBrush200}" HorizontalAlignment="Right" Command="{Binding CreateColorDataImportExcelTemplateCommand}" ToolTip="Create excel file template" Margin="0 0 5 0">
+                                        <materialDesign:PackIcon Kind="FileExcel" Foreground="{StaticResource DimGrayBrush}" Width="16" Height="26" />
+                                    </Button>
+                                    <Button DockPanel.Dock="Right" HorizontalAlignment="Left"  Padding="2" Height="26" Width="140" Background="Transparent" Command="{Binding SelectedTab.ImportCyanDataCommand}" ToolTip="Import Cyan data " Margin="0 0 10 0" BorderBrush="{StaticResource TransparentBackgroundBrush200}" BorderThickness="1 1 0.8 2">
+                                        <TextBlock FontSize="14"  Foreground="{StaticResource MainWindow.Foreground}">IMPORT DATA</TextBlock>
+                                    </Button>
+                                    <TextBlock  VerticalAlignment="Center" HorizontalAlignment="Left" Margin="20 4 0 0" FontSize="16" Padding="0">LIQUID TYPE CYAN</TextBlock>
+                                </DockPanel>
+                            </Grid>
+                        </Border>
+                        <Grid Grid.Row="1">
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="1*"/>
+                                <ColumnDefinition Width="Auto"/>
+                            </Grid.ColumnDefinitions>
+                            <ContentControl Name="cyanChartsContent" Grid.Row="1" ContentTemplate="{StaticResource chartsPanel}" Content="{Binding SelectedTab.CyanPlot}"/>
+                            <ContentControl ContentTemplate="{StaticResource calibrationDataGrid}" Content="{Binding SelectedTab.CyanCalibrationData}" Grid.Column="1"/>
+                        </Grid>
+                    </DockPanel>
+                    <DockPanel Grid.Column="1">
+                        <Border DockPanel.Dock="Top"  Background="#FC63FC" Margin="20 0 0 0 " Padding="5" CornerRadius="5" Height="40" VerticalAlignment="Top">
+                            <Border.Effect>
+                                <DropShadowEffect Opacity="0.4" />
+                            </Border.Effect>
+                            <Grid>
+                                <DockPanel>
+                                    <Button Height="Auto" DockPanel.Dock="Right" Style="{StaticResource MaterialDesignFlatButton}" Padding="0" FontSize="11" Foreground="{StaticResource DarkGrayBrush200}" HorizontalAlignment="Right" Command="{Binding CreateColorDataImportExcelTemplateCommand}" ToolTip="Create excel file template" Margin="0 0 5 0">
+                                        <materialDesign:PackIcon Kind="FileExcel" Foreground="{StaticResource DimGrayBrush}" Width="16" Height="26" />
+                                    </Button>
+                                    <Button DockPanel.Dock="Right" HorizontalAlignment="Left"  Height="26" Padding="2" Width="140" Background="Transparent" Command="{Binding SelectedTab.ImportMagentaDataCommand}" ToolTip="Import Magenta data " Margin="0 0 10 0" BorderBrush="{StaticResource TransparentBackgroundBrush200}" BorderThickness="1 1 0.8 2">
+                                        <TextBlock FontSize="14"  Foreground="{StaticResource MainWindow.Foreground}">IMPORT DATA</TextBlock>
+                                    </Button>
+                                    <TextBlock  VerticalAlignment="Center" HorizontalAlignment="Left" Margin="20 4 0 0" FontSize="16" Padding="0">LIQUID TYPE MAGENTA</TextBlock>
+                                </DockPanel>
+                            </Grid>
+                        </Border>
+                        <Grid Grid.Row="1">
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="1*"/>
+                                <ColumnDefinition Width="Auto"/>
+                            </Grid.ColumnDefinitions>
+                            <ContentControl Name="magentaChartsContent" ContentTemplate="{StaticResource chartsPanel}" Content="{Binding SelectedTab.MagentaPlot}"/>
+                            <ContentControl ContentTemplate="{StaticResource calibrationDataGrid}" Content="{Binding SelectedTab.MagentaCalibrationData}" Grid.Column="1"/>
+                        </Grid>
+                    </DockPanel >
+                    <DockPanel Grid.Column="0" Grid.Row="1" x:Name="YellowPanel">
+                        <Border DockPanel.Dock="Top"  Background="LightYellow" Margin="20 0 0 0 " Padding="5" CornerRadius="5" Height="40" VerticalAlignment="Top">
+                            <Border.Effect>
+                                <DropShadowEffect Opacity="0.4" />
+                            </Border.Effect>
+                            <Grid>
+                                <DockPanel>
+                                    <Button Height="Auto" DockPanel.Dock="Right" Style="{StaticResource MaterialDesignFlatButton}" Padding="0" FontSize="11" Foreground="{StaticResource DarkGrayBrush200}" HorizontalAlignment="Right" Command="{Binding CreateColorDataImportExcelTemplateCommand}" ToolTip="Create excel file template" Margin="0 0 5 0">
+                                        <materialDesign:PackIcon Kind="FileExcel" Foreground="{StaticResource DimGrayBrush}" Width="16" Height="26" />
+                                    </Button>
+                                    <Button DockPanel.Dock="Right" HorizontalAlignment="Left"  Height="26" Padding="2" Width="140" Background="Transparent" Command="{Binding SelectedTab.ImportYellowDataCommand}" ToolTip="Import Yellow data " Margin="0 0 10 0" BorderBrush="{StaticResource TransparentBackgroundBrush200}" BorderThickness="1 1 0.8 2">
+                                        <TextBlock FontSize="14"  Foreground="{StaticResource MainWindow.Foreground}">IMPORT DATA</TextBlock>
+                                    </Button>
+                                    <TextBlock  VerticalAlignment="Center" HorizontalAlignment="Left" Margin="20 4 0 0" FontSize="16" Padding="0">LIQUID TYPE YELLOW</TextBlock>
+                                </DockPanel>
+                            </Grid>
+                        </Border>
+                        <Grid Grid.Row="1">
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="1*"/>
+                                <ColumnDefinition Width="Auto"/>
+                            </Grid.ColumnDefinitions>
+                            <ContentControl Name="yellowChartsContent"  ContentTemplate="{StaticResource chartsPanel}" Content="{Binding SelectedTab.YellowPlot}"/>
+                            <ContentControl ContentTemplate="{StaticResource calibrationDataGrid}" Content="{Binding SelectedTab.YellowCalibrationData}" Grid.Column="1"/>
+                        </Grid>
+                    </DockPanel>
+                    <DockPanel  Grid.Column="1" Grid.Row="1">
+                        <Border DockPanel.Dock="Top"  Background="DarkGray" Margin="20 0 0 0 " Padding="5" CornerRadius="5" Height="40" VerticalAlignment="Top">
+                            <Border.Effect>
+                                <DropShadowEffect Opacity="0.4" />
+                            </Border.Effect>
+                            <Grid>
+                                <DockPanel>
+                                    <Button Height="Auto" DockPanel.Dock="Right" Style="{StaticResource MaterialDesignFlatButton}" Padding="0" FontSize="11" Foreground="{StaticResource DarkGrayBrush200}" HorizontalAlignment="Right" Command="{Binding CreateColorDataImportExcelTemplateCommand}" ToolTip="Create excel file template" Margin="0 0 5 0">
+                                        <materialDesign:PackIcon Kind="FileExcel" Foreground="{StaticResource DimGrayBrush}" Width="16" Height="26" />
+                                    </Button>
+                                    <Button DockPanel.Dock="Right" HorizontalAlignment="Left"  Height="26" Padding="2" Width="140" Background="Transparent" Command="{Binding SelectedTab.ImportBlackDataCommand}" ToolTip="Import Black data " Margin="0 0 10 0" BorderBrush="{StaticResource TransparentBackgroundBrush200}" BorderThickness="1 1 0.8 2" >
+                                        <TextBlock FontSize="14"  Foreground="{StaticResource MainWindow.Foreground}">IMPORT DATA</TextBlock>
+                                    </Button>
+                                    <TextBlock  VerticalAlignment="Center" HorizontalAlignment="Left" Margin="20 4 0 0" FontSize="16" Padding="0">LIQUID TYPE BLACK</TextBlock>
+                                </DockPanel>
+                            </Grid>
+
+                        </Border>
+                        <Grid Grid.Row="1">
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="1*"/>
+                                <ColumnDefinition Width="Auto"/>
+                            </Grid.ColumnDefinitions>
+                            <ContentControl Name="blackChartsContent"  ContentTemplate="{StaticResource chartsPanel}" Content="{Binding SelectedTab.BlackPlot}"/>
+                            <ContentControl ContentTemplate="{StaticResource calibrationDataGrid}" Content="{Binding SelectedTab.BlackCalibrationData}" Grid.Column="1"/>
+                        </Grid>
+                    </DockPanel>
+                </UniformGrid>
+            </DockPanel>
+        </Grid>
+    </Grid>
+</UserControl>
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..84219c093
--- /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
+{
+    /// <summary>
+    /// Interaction logic for ColorCalibrationView.xaml
+    /// </summary>
+    public partial class ColorCalibrationView : UserControl
+    {
+        public ColorCalibrationView()
+        {
+            InitializeComponent();
+        }
+        
+        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;
+                if (selectedTab != null && !selectedTab.IsTabLoaded)
+                {
+                    InitPlots(selectedTab);
+                    vm.IsViewLoaded = true;
+                }
+            }
+        }
+        
+        private void ListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            var listBox = (UIElement)sender;
+            if (listBox != null && ((ListBox)listBox).DataContext is ColorCalibrationViewVM)
+            {
+                ColorCalibrationViewVM vm = (ColorCalibrationViewVM)((ListBox)listBox).DataContext;
+                ColorCalibrationTabVM selectedTab = vm.SelectedTab;
+                InitPlots(selectedTab);
+            }
+        }
+
+        private void InitPlots(ColorCalibrationTabVM selectedTab)
+        {
+            if (selectedTab != null && !selectedTab.IsTabLoaded)
+            {
+                if (null == (cyanChartsContent as FrameworkElement).FindChild<Plot>("LABDataPlot"))
+                    return;
+                selectedTab.CyanPlot.DataPlotControl = (cyanChartsContent as FrameworkElement).FindChild<Plot>("LABDataPlot");
+                selectedTab.CyanPlot.LinearizationPlotControl = (cyanChartsContent as FrameworkElement).FindChild<Plot>("LinearizationPlot");
+                selectedTab.MagentaPlot.DataPlotControl = (magentaChartsContent as FrameworkElement).FindChild<Plot>("LABDataPlot");
+                selectedTab.MagentaPlot.LinearizationPlotControl = (magentaChartsContent as FrameworkElement).FindChild<Plot>("LinearizationPlot");
+                selectedTab.YellowPlot.DataPlotControl = (yellowChartsContent as FrameworkElement).FindChild<Plot>("LABDataPlot");
+                selectedTab.YellowPlot.LinearizationPlotControl = (yellowChartsContent as FrameworkElement).FindChild<Plot>("LinearizationPlot");
+                selectedTab.BlackPlot.DataPlotControl = (blackChartsContent as FrameworkElement).FindChild<Plot>("LABDataPlot");
+                selectedTab.BlackPlot.LinearizationPlotControl = (blackChartsContent as FrameworkElement).FindChild<Plot>("LinearizationPlot");
+
+                selectedTab.InitData();
+                selectedTab.IsTabLoaded = true;
+            }
+        }
+    }
+}
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/ColorShadeView.xaml b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/ColorShadeView.xaml
new file mode 100644
index 000000000..b9341d0de
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/ColorShadeView.xaml
@@ -0,0 +1,197 @@
+<UserControl x:Class="Tango.MachineStudio.ThreadExtensions.Views.ColorShadeView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             xmlns:converters="clr-namespace:Tango.SharedUI.Converters;assembly=Tango.SharedUI"
+             xmlns:mahapps="http://metro.mahapps.com/winfx/xaml/controls"
+             xmlns:autoCompleteMachine="clr-namespace:Tango.MachineStudio.Common.AutoComplete;assembly=Tango.MachineStudio.Common"
+             xmlns:local="clr-namespace:Tango.MachineStudio.ThreadExtensions.Views"
+             xmlns:materialDesign="http://materialdesigninxaml.net/winfx/xaml/themes"
+             xmlns:vm="clr-namespace:Tango.MachineStudio.ThreadExtensions.ViewModels"
+              xmlns:fa="http://schemas.fontawesome.io/icons/"
+             mc:Ignorable="d" 
+             d:DesignHeight="450" d:DesignWidth="800" Background="Transparent" d:DataContext="{d:DesignInstance Type=vm:ColorShadeViewVM, IsDesignTimeCreatable=False}" FontSize="16">
+
+    <UserControl.Resources>
+        <autoCompleteMachine:MachinesProvider x:Key="MachinesProvider" />
+        <converters:EnumToDescriptionConverter x:Key="EnumToDescriptionConverter" />
+
+        
+        <Style TargetType="DataGridCell" BasedOn="{StaticResource {x:Type DataGridCell}}">
+            <Setter Property="BorderThickness" Value="0"/>
+            <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
+            <Setter Property="VerticalContentAlignment" Value="Center"></Setter>
+        </Style>
+        
+    </UserControl.Resources>
+
+    <Grid x:Name="contentGrid" DataContext="{Binding  ColorShadeViewVM}" >
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="1*"/>
+        </Grid.RowDefinitions>
+
+        <DockPanel Grid.Row="0">
+            <Button DockPanel.Dock="Right" HorizontalAlignment="Right" Width="170" Height="36" Margin="0 0 26 0" VerticalAlignment="Center" Command="{Binding SaveCommand}">
+                <StackPanel Orientation="Horizontal">
+                    <materialDesign:PackIcon Kind="ContentSaveAll" Width="24" Height="24" />
+                    <TextBlock VerticalAlignment="Center" Margin="10 0 0 0">SAVE</TextBlock>
+                </StackPanel>
+            </Button>
+        </DockPanel>
+        <Grid Grid.Row="1" >
+            <Grid.RowDefinitions>
+                <RowDefinition Height="30"/>
+                <RowDefinition Height="1*"/>
+            </Grid.RowDefinitions>
+            <StackPanel Orientation="Horizontal" Margin="35 0 0 0">
+                <ListBox Style="{x:Null}" HorizontalAlignment="Left" HorizontalContentAlignment="Stretch" VerticalContentAlignment="Stretch" ItemContainerStyle="{StaticResource basicListBoxItem}" ScrollViewer.HorizontalScrollBarVisibility="Disabled" ScrollViewer.VerticalScrollBarVisibility="Disabled" Background="Transparent" BorderThickness="0" ItemsSource="{Binding ColorShadeTabs}" SelectedItem="{Binding SelectedTab}">
+                    <ListBox.ItemsPanel>
+                        <ItemsPanelTemplate>
+                            <StackPanel HorizontalAlignment="Left" Orientation="Horizontal"></StackPanel>
+                        </ItemsPanelTemplate>
+                    </ListBox.ItemsPanel>
+
+                    <ListBox.ItemTemplate>
+                        <DataTemplate>
+                            <Border Padding="5 5" Width="160" CornerRadius="10 10 0 0" Margin="1 0" Tag="{Binding RelativeSource={RelativeSource AncestorType=ListBox},Path=DataContext}">
+                                <Border.ContextMenu>
+                                    <ContextMenu DataContext="{Binding Path=PlacementTarget.Tag, RelativeSource={RelativeSource Self}}" Style="{x:Null}" >
+                                        <MenuItem Header="Rename" Command="{Binding RenameTabCommand}" MinWidth="210" MaxHeight="40" >
+                                            <MenuItem.Icon>
+                                                <fa:ImageAwesome Icon="Pencil" Width="16" />
+                                            </MenuItem.Icon>
+                                        </MenuItem>
+                                    </ContextMenu>
+                                </Border.ContextMenu>
+                                <Border.Style>
+                                    <Style TargetType="Border">
+                                        <Setter Property="Background" Value="{StaticResource LightGrayBrush150}"></Setter>
+                                        <Setter Property="TextElement.Foreground" Value="{StaticResource DarkGrayBrush}"></Setter>
+                                        <Style.Triggers>
+                                            <DataTrigger Binding="{Binding IsSelected}" Value="True">
+                                                <Setter Property="Background" Value="{StaticResource AccentColorBrush}"></Setter>
+                                                <Setter Property="TextElement.Foreground" Value="{StaticResource WhiteTextBrush}"></Setter>
+                                            </DataTrigger>
+                                            <Trigger Property="IsMouseOver" Value="True">
+                                                <Setter Property="Opacity" Value="0.8"></Setter>
+                                            </Trigger>
+                                        </Style.Triggers>
+                                    </Style>
+                                </Border.Style>
+                                <DockPanel VerticalAlignment="Center">
+                                    <Button Cursor="Hand" Command="{Binding RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=ListBox}, Path=DataContext.RemoveTabCommand}" CommandParameter="{Binding }" DockPanel.Dock="Right" Margin="5 0 0 0" Style="{StaticResource MaterialDesignFlatButton}" Padding="2" Height="Auto">
+                                        <materialDesign:PackIcon Kind="Close">
+                                            <materialDesign:PackIcon.Style>
+                                                <Style TargetType="materialDesign:PackIcon">
+                                                    <Setter Property="Foreground" Value="{StaticResource DarkGrayBrush}"></Setter>
+                                                    <Style.Triggers>
+                                                        <DataTrigger Binding="{Binding IsSelected}" Value="True">
+                                                            <Setter Property="Foreground" Value="{StaticResource WhiteTextBrush}"></Setter>
+                                                        </DataTrigger>
+                                                    </Style.Triggers>
+                                                </Style>
+                                            </materialDesign:PackIcon.Style>
+                                        </materialDesign:PackIcon>
+                                    </Button>
+                                    <TextBlock Text="{Binding Name}" VerticalAlignment="Center" TextAlignment="Center" TextTrimming="CharacterEllipsis" FontSize="11"></TextBlock>
+                                </DockPanel>
+                            </Border>
+                        </DataTemplate>
+                    </ListBox.ItemTemplate>
+                </ListBox>
+                <Button Margin="10 0 0 0" Style="{StaticResource MaterialDesignFlatButton}" Padding="2" Height="24" Cursor="Hand" Command="{Binding AddTabCommand}" ToolTip="New tab">
+                    <materialDesign:PackIcon Width="20" Height="20" Kind="Plus" Foreground="{StaticResource AccentColorBrush}" />
+                </Button>
+            </StackPanel>
+
+            <Border Margin="5 0 5 5" Grid.Row="1" Background="Transparent"  Padding="4"  CornerRadius="5"  VerticalAlignment="Top" BorderThickness="2" BorderBrush="{StaticResource borderBrush}">
+                 <DockPanel >
+                    <DockPanel DockPanel.Dock="Top" Height="30">
+                        <Button Height="Auto" DockPanel.Dock="Right" Style="{StaticResource MaterialDesignFlatButton}"  FontSize="11" Foreground="{StaticResource DarkGrayBrush200}" HorizontalAlignment="Right" Command="{Binding CreateColorDataImportExcelTemplateCommand}" ToolTip="Create excel file template" Margin="0 0 10 0">
+                            <materialDesign:PackIcon Kind="FileExcel" Foreground="{StaticResource DimGrayBrush}" Width="26" Height="24" />
+                        </Button>
+                        <Button DockPanel.Dock="Right" HorizontalAlignment="Right" Height="Auto" Width="180"  Command="{Binding SelectedTab.ImportColorsCommand}" ToolTip="Import Cyan data " Margin="0 0 10 0" >
+                            <TextBlock FontSize="14" VerticalAlignment="Center" >IMPORT COLORS</TextBlock>
+                        </Button>
+                    </DockPanel>
+                    <Grid  DockPanel.Dock="Bottom" Margin="0 0 0 0">
+                        <DataGrid  Margin="10" BorderBrush="Silver" BorderThickness="1" RowHeight="30" Background="{StaticResource TransparentBackgroundBrush}" AlternatingRowBackground="{StaticResource Transparent200}" AutoGenerateColumns="False" CanUserAddRows="True" CanUserDeleteRows="True" ItemsSource="{Binding SelectedTab.RmlExtensionColorShadesTest.RmlExtensionColorShadesTestsData}" IsReadOnly="False" 
+                                  ScrollViewer.CanContentScroll="True" ScrollViewer.VerticalScrollBarVisibility="Auto" MinHeight="700">
+                            <DataGrid.ColumnHeaderStyle >
+                                <Style TargetType="{x:Type DataGridColumnHeader}" BasedOn="{StaticResource {x:Type DataGridColumnHeader}}">
+                                    <Setter Property="FontSize" Value="16"/>
+                                    <Setter Property="HorizontalAlignment" Value="Center"/>
+                                    <Setter Property="VerticalAlignment" Value="Center"/>
+                                    <Setter Property="Margin" Value="2 0 0 0"/>
+                                    <Setter Property="Padding" Value="0 5"/>
+                                    <Setter Property="FrameworkElement.HorizontalAlignment" Value="Stretch"/>
+                                    <Setter Property="HorizontalContentAlignment" Value="Center"/>
+                                </Style>
+                            </DataGrid.ColumnHeaderStyle>
+                            <DataGrid.CellStyle>
+                                <Style TargetType="DataGridCell" BasedOn="{StaticResource {x:Type DataGridCell}}">
+                                    <Setter Property="BorderThickness" Value="0"/>
+                                    <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
+                                    <Setter Property="VerticalContentAlignment" Value="Center"></Setter>
+                                    <Setter Property="Padding" Value="4"></Setter>
+                                    <Setter Property="Margin" Value="0 0 0 0"></Setter>
+                                </Style>
+                            </DataGrid.CellStyle>
+                            <DataGrid.Columns>
+                                <DataGridTextColumn Header="Number" Binding="{Binding ColorNum}" Width="80" />
+                                <DataGridTemplateColumn Header="Shade" Width="200">
+                                    <DataGridTemplateColumn.CellTemplate>
+                                        <DataTemplate>
+                                            <Rectangle Fill="{Binding ColorBrush, Mode=OneWay}"/>
+                                        </DataTemplate>
+                                    </DataGridTemplateColumn.CellTemplate>
+                                </DataGridTemplateColumn>
+
+                                <DataGridTextColumn Header="L" Binding="{Binding L, UpdateSourceTrigger=PropertyChanged}" Width="1*" />
+                                <DataGridTextColumn Header="A" Binding="{Binding A, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" Width="1*"/>
+                                <DataGridTextColumn Header="B" Binding="{Binding B, UpdateSourceTrigger=PropertyChanged}" Width="1*"/>
+                                <DataGridTextColumn Header="C" Binding="{Binding C, UpdateSourceTrigger=PropertyChanged}" Width="1*" />
+                                <DataGridTextColumn Header="M" Binding="{Binding M, UpdateSourceTrigger=PropertyChanged}" Width="1*"/>
+                                <DataGridTextColumn Header="Y" Binding="{Binding Y, UpdateSourceTrigger=PropertyChanged}" Width="1*"/>
+                                <DataGridTextColumn Header="K" Binding="{Binding K, UpdateSourceTrigger=PropertyChanged}" Width="1*" />
+                                <DataGridTextColumn Header="TI" Binding="{Binding TI, UpdateSourceTrigger=PropertyChanged}" Width="1*"/>
+                                <DataGridTextColumn Header="L" Binding="{Binding LRes, UpdateSourceTrigger=PropertyChanged}" Width="1*">
+                                    <DataGridTextColumn.CellStyle>
+                                        <Style TargetType="DataGridCell" BasedOn="{StaticResource {x:Type DataGridCell}}">
+                                            <Setter Property="Background" Value="LightCyan" />
+                                        </Style>
+                                    </DataGridTextColumn.CellStyle>
+                                </DataGridTextColumn>
+                                <DataGridTextColumn Header="A" Binding="{Binding ARes}" Width="1*" >
+                                    <DataGridTextColumn.CellStyle>
+                                        <Style TargetType="DataGridCell" BasedOn="{StaticResource {x:Type DataGridCell}}">
+                                            <Setter Property="Background" Value="LightCyan" />
+                                        </Style>
+                                    </DataGridTextColumn.CellStyle>
+                                </DataGridTextColumn>
+                                <DataGridTextColumn Header="B" Binding="{Binding BRes}" Width="1*">
+                                    <DataGridTextColumn.CellStyle>
+                                        <Style TargetType="DataGridCell" BasedOn="{StaticResource {x:Type DataGridCell}}">
+                                            <Setter Property="Background" Value="LightCyan" />
+                                        </Style>
+                                    </DataGridTextColumn.CellStyle>
+                                </DataGridTextColumn>
+                                <DataGridTextColumn Header="Delta E" Binding="{Binding DeltaE}" Width="1*">
+                                    <DataGridTextColumn.CellStyle>
+                                        <Style TargetType="DataGridCell" BasedOn="{StaticResource {x:Type DataGridCell}}">
+                                            <Setter Property="Background" Value="LightCyan" />
+                                            <Setter Property="Foreground" Value="red" />
+                                            <Setter Property="VerticalContentAlignment" Value="Center"></Setter>
+                                        </Style>
+                                    </DataGridTextColumn.CellStyle>
+                                </DataGridTextColumn>
+                            </DataGrid.Columns>
+                        </DataGrid>
+                    </Grid>
+                </DockPanel>
+                </Border>
+        </Grid>
+    </Grid>
+</UserControl>
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/ColorShadeView.xaml.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/ColorShadeView.xaml.cs
new file mode 100644
index 000000000..2a8079cfe
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/ColorShadeView.xaml.cs
@@ -0,0 +1,28 @@
+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.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;
+
+namespace Tango.MachineStudio.ThreadExtensions.Views
+{
+    /// <summary>
+    /// Interaction logic for ColorShadeView.xaml
+    /// </summary>
+    public partial class ColorShadeView : UserControl
+    {
+        public ColorShadeView()
+        {
+            InitializeComponent();
+        }
+    }
+}
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..820c68715 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,12 @@
                     <TabItem Header="TEST RESULTS" Margin="20 0 0 0" mahapps:ControlsHelper.HeaderFontSize="20" >
                         <local:TestResultsView />
                     </TabItem>
+                    <TabItem Header="COLOR CALIBRATION" Margin="20 0 0 0" mahapps:ControlsHelper.HeaderFontSize="20">
+                        <local:ColorCalibrationView/>
+                    </TabItem>
+                    <TabItem Header="COLOR SHADE" Margin="20 0 0 0" mahapps:ControlsHelper.HeaderFontSize="20">
+                        <local:ColorShadeView/>
+                    </TabItem>
                 </TabControl>
             </Grid>
         </DockPanel>
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/TestResultsView.xaml b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/TestResultsView.xaml
index 50a2537e1..f6262b52d 100644
--- a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/TestResultsView.xaml
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/Views/TestResultsView.xaml
@@ -158,33 +158,12 @@
 
     </UserControl.Resources>
     <Grid  DataContext="{Binding  TestResultsViewVM}">
-        <Grid.RowDefinitions>
+        <!--<Grid.RowDefinitions>
             <RowDefinition Height="Auto"/>
             <RowDefinition Height="1*"/>
-        </Grid.RowDefinitions>
-        <DockPanel Grid.Row="0">
-            <Button DockPanel.Dock="Top" HorizontalAlignment="Right" Width="170" Height="36" Margin="0 0 26 0" VerticalAlignment="Center" Command="{Binding SaveCommand}">
-                <StackPanel Orientation="Horizontal">
-                    <materialDesign:PackIcon Kind="ContentSaveAll" Width="24" Height="24" />
-                    <TextBlock VerticalAlignment="Center" Margin="10 0 0 0">SAVE</TextBlock>
-                </StackPanel>
-            </Button>
-            <!--<StackPanel Orientation="Horizontal" DockPanel.Dock="Top">
-                <TextBlock Margin="40 20" FontSize="30" FontWeight="SemiBold" FontStyle="Italic">TARGET MACHINE</TextBlock>
-
-                <autoComplete:AutoCompleteTextBox Provider="{StaticResource MachinesProvider}" LoadingContent="Loading..."  FontSize="20" SelectedItem="{Binding SelectedMachine,Mode=TwoWay}" materialDesign:HintAssist.Hint="Serial Number" DisplayMember="SerialNumber" Width="280">
-                    <autoComplete:AutoCompleteTextBox.ItemTemplate>
-                        <DataTemplate>
-                            <StackPanel>
-                                <TextBlock Text="{Binding SerialNumber}" FontWeight="Bold" FontStyle="Italic"></TextBlock>
-                                <TextBlock FontSize="11" Text="{Binding Name}" Foreground="Gray"></TextBlock>
-                            </StackPanel>
-                        </DataTemplate>
-                    </autoComplete:AutoCompleteTextBox.ItemTemplate>
-                </autoComplete:AutoCompleteTextBox>
-            </StackPanel>-->
-        </DockPanel>
-        <Grid Grid.Row="1" >
+        </Grid.RowDefinitions>-->
+       
+        <Grid Grid.Row="1" Margin="0 8 0 0" >
             <Grid.RowDefinitions>
                 <RowDefinition Height="30"/>
                 <RowDefinition Height="1*"/>
@@ -265,22 +244,17 @@
                 </ItemsControl>
 
                 <Grid Grid.Column="0" MinWidth="600" HorizontalAlignment="Left" >
-                    <DockPanel >
-
-                        <Grid DockPanel.Dock="Bottom" Margin="20 10 20 40">
-                            <TextBlock FontSize="21">Conclusion:</TextBlock>
-                            <TextBox Margin="120 0 10 0" HorizontalAlignment="Stretch" Height="46" Text="{Binding SelectedTab.TestResult.Conclusions}" Style="{StaticResource Rounded_Corners_TextBox_Multiline}"></TextBox>
-                        </Grid>
-
-                        <Grid DockPanel.Dock="Bottom" Margin="20 10 20 0">
-                            <TextBlock FontSize="21">Comments:</TextBlock>
-                            <TextBox Margin="120 0 10 0"  Style="{StaticResource Rounded_Corners_TextBox_Multiline}"   HorizontalAlignment="Stretch" Height="46" Text="{Binding SelectedTab.TestResult.Comment}"></TextBox>
+                    <Grid.RowDefinitions>
+                        <RowDefinition Height="3*"/>
+                        <RowDefinition Height="1*"/>
+                    </Grid.RowDefinitions>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="1*"/>
+                        <ColumnDefinition Width="1*"/>
+                    </Grid.ColumnDefinitions>
 
-                        </Grid>
-                        
-                        <Border Padding="10 10 20 10" DockPanel.Dock="Top" BorderBrush="Transparent"  BorderThickness="1" >
-                            
-                            <ScrollViewer VerticalScrollBarVisibility="Auto"  >
+                    <Border Padding="10 10 20 10" Grid.ColumnSpan="2" Grid.Row="0" BorderBrush="Transparent"  BorderThickness="1" >
+                        <ScrollViewer VerticalScrollBarVisibility="Auto"  >
                                 <Grid HorizontalAlignment="Left">
                                     <Grid.ColumnDefinitions>
                                         <ColumnDefinition Width="1*"></ColumnDefinition>
@@ -293,8 +267,8 @@
                                     </Grid.RowDefinitions>
                                     <Border>
                                     <StackPanel x:Name="DryerTempPanel"  HorizontalAlignment="Stretch" Grid.Column="0" Grid.Row="0" >
-                                            <DockPanel Margin="0 0 0 0">
-                                                <Button DockPanel.Dock="Right" Margin="0 0 40 0" HorizontalAlignment="Left"  Padding="0" Height="Auto" Width="200"  Command="{Binding ApplyToProcessParametersCommand}" ToolTip="Apply to Process Parameters" VerticalContentAlignment="Center">
+                                            <DockPanel Margin="0 10 0 0">
+                                                <Button DockPanel.Dock="Right" Margin="0 0 40 0" HorizontalAlignment="Left"  Padding="0"  Width="200"  Command="{Binding ApplyToProcessParametersCommand}" ToolTip="Apply to Process Parameters" VerticalContentAlignment="Center">
                                                     <TextBlock FontSize="14" Background="Transparent"  VerticalAlignment="Center" Margin="0 2 0 0">Apply to Process Parameters</TextBlock>
                                                 </Button>
                                                 <TextBlock HorizontalAlignment="Center"  FontSize="21" Margin="180 10 0 0"> Process Parameters</TextBlock>
@@ -390,7 +364,7 @@
                                         </DataGrid>
 
                                     </StackPanel>
-                                    <StackPanel x:Name="TensionresultsPanel" Grid.Column="1" Grid.Row="0" Margin="0 10 0 0" >
+                                    <StackPanel x:Name="TensionresultsPanel" Grid.Column="1" Grid.Row="0" Margin="0 20 0 0" >
                                         <TextBlock HorizontalAlignment="Center" FontSize="21"> Tension through the thread path</TextBlock>
                                         <Border BorderThickness="1" BorderBrush="{StaticResource GrayBrush200}" Margin="0 10 20 10" >
                                             <UniformGrid Columns="4"  Background="{StaticResource TransparentBackgroundBrush}"  HorizontalAlignment="Left" MinWidth="{ Binding ElementName=MechanicalPropertiesGrid, Path= ActualWidth }" >
@@ -631,10 +605,93 @@
                         </ScrollViewer>
                         </Border>
                         
+                    <Grid Grid.Row="1" Grid.Column="1" Margin="0 0 20 20">
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="120"/>
+                            <ColumnDefinition Width="1*"/>
+                        </Grid.ColumnDefinitions>
+                        <Grid.RowDefinitions>
+                            <RowDefinition Height="1*"/>
+                            <RowDefinition Height="1*" />
+                        </Grid.RowDefinitions>
+
+                        <TextBlock FontSize="21" HorizontalAlignment="Left"  VerticalAlignment="Center">Conclusion:</TextBlock>
+                        <TextBox Grid.Column="1" Margin="20 0 20 0" HorizontalAlignment="Stretch" Height="46" Text="{Binding SelectedTab.TestResult.Conclusions}" Style="{StaticResource Rounded_Corners_TextBox_Multiline}"></TextBox>
+
+                        <TextBlock Grid.Row="1" FontSize="21" HorizontalAlignment="Left" VerticalAlignment="Center">Comments:</TextBlock>
+                        <TextBox Grid.Column="1" Grid.Row="1" Margin="20 0 20 0"  Style="{StaticResource Rounded_Corners_TextBox_Multiline}"   HorizontalAlignment="Stretch" Height="46" Text="{Binding SelectedTab.TestResult.Comment}" VerticalAlignment="Center"></TextBox>
+                            
+                    </Grid>
+                    <DockPanel  Grid.Row="1" Grid.Column="0" Margin="20 0 20 20" x:Name="ImportExcelFile">
+                        <DockPanel DockPanel.Dock="Top" Margin="0 0 20 0">
+                            <Button  Margin="10 0 0 0"  Padding="2" Height="24" Cursor="Hand" Width="100" Command="{Binding SelectedTab.UploadCommand}" ToolTip="Upload selected files">Upload</Button>
+                            <Button DockPanel.Dock="Right" Margin="0 0 10 0" HorizontalAlignment="Right" Padding="2" Height="24" Cursor="Hand" Width="100" Command="{Binding SelectedTab.DownLoadAllCommand}" ToolTip="Upload selected files">Download All</Button>
+                        </DockPanel>
+                        
+                        <Grid  DockPanel.Dock="Bottom" Margin="0 0 20 0">
+                            <DataGrid  Margin="10" RowHeight="30" Padding="0"  SelectionUnit="FullRow" BorderBrush="{StaticResource DarkGrayBrush }" BorderThickness="1" Background="{StaticResource TransparentBackgroundBrush}" AlternatingRowBackground="{StaticResource Transparent200}"  AutoGenerateColumns="False" CanUserAddRows="False" CanUserDeleteRows="False" ItemsSource="{Binding SelectedTab.TestResultsFiles}" IsReadOnly="True" 
+                                  ScrollViewer.CanContentScroll="True" ScrollViewer.VerticalScrollBarVisibility="Auto" MinHeight="100">
+                                <DataGrid.ColumnHeaderStyle >
+                                    <Style TargetType="{x:Type DataGridColumnHeader}" BasedOn="{StaticResource {x:Type DataGridColumnHeader}}">
+                                        <Setter Property="FontSize" Value="16"/>
+                                        <Setter Property="HorizontalAlignment" Value="Left"/>
+                                        <Setter Property="Margin" Value="2 0 0 0"/>
+                                        <Setter Property="Padding" Value="0 5"/>
+                                        <Setter Property="FrameworkElement.HorizontalAlignment" Value="Stretch"/>
+                                        <Setter Property="HorizontalContentAlignment" Value="Left"/>
+                                    </Style>
+                                </DataGrid.ColumnHeaderStyle>
+                                <DataGrid.CellStyle>
+                                    <Style TargetType="DataGridCell" BasedOn="{StaticResource {x:Type DataGridCell}}">
+                                        <Setter Property="BorderThickness" Value="0"/>
+                                        <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
+                                        <Setter Property="VerticalContentAlignment" Value="Center"></Setter>
+                                        <Setter Property="Padding" Value="0"></Setter>
+                                        <Setter Property="Margin" Value="0 0 0 0"></Setter>
+                                    </Style>
+                                </DataGrid.CellStyle>
+                                <DataGrid.Columns>
+                                    <DataGridTextColumn Header="File Name" Binding="{Binding FileName}" Width="1*" FontSize="16"/>
+                                    <DataGridTextColumn Header="Progress"  Width="1*" />
+                                    <DataGridTemplateColumn Header="DownLoad" Width="140">
+                                        <DataGridTemplateColumn.CellTemplate>
+                                            <DataTemplate>
+                                                <Button Style="{StaticResource emptyButton}" Cursor="Hand"  Command="{Binding RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type Grid},AncestorLevel=2},Path=DataContext.SelectedTab.DownLoadFileCommand}" CommandParameter="{Binding}">
+                                                    <StackPanel Orientation="Horizontal">
+                                                        <TextBlock FontSize="16" Text="Download" VerticalAlignment="Center"></TextBlock>
+                                                        <materialDesign:PackIcon VerticalAlignment="Center" Margin="5 0 0 0" Kind="Download" Width="18" />
+                                                    </StackPanel>
+                                                </Button>
+                                            </DataTemplate>
+                                        </DataGridTemplateColumn.CellTemplate>
+                                    </DataGridTemplateColumn>
+                                    <DataGridTemplateColumn Header="Delete" Width="140">
+                                        <DataGridTemplateColumn.CellTemplate>
+                                            <DataTemplate>
+                                                <Button Style="{StaticResource emptyButton}" Cursor="Hand"  Command="{Binding RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type Grid},AncestorLevel=2},Path=DataContext.SelectedTab.DeleteCommand}" CommandParameter="{Binding}">
+                                                <StackPanel Orientation="Horizontal">
+                                                    <TextBlock FontSize="16" Text="Delete" VerticalAlignment="Center"></TextBlock>
+                                                    <materialDesign:PackIcon VerticalAlignment="Center" Margin="5 0 0 0" Kind="Delete" Width="18"  />
+                                                </StackPanel>
+                                            </Button>
+                                            </DataTemplate>
+                                        </DataGridTemplateColumn.CellTemplate>
+                                    </DataGridTemplateColumn>
+                                </DataGrid.Columns>
+                            </DataGrid>
+                        </Grid>
                     </DockPanel>
                 </Grid>
             </Grid>
         </Grid>
-
+        <DockPanel VerticalAlignment="Top">
+            <Button DockPanel.Dock="Top" HorizontalAlignment="Right" Width="170" Height="36" Margin="0 0 26 0" VerticalAlignment="Center" Command="{Binding SaveCommand}">
+                <StackPanel Orientation="Horizontal">
+                    <materialDesign:PackIcon Kind="ContentSaveAll" Width="24" Height="24" />
+                    <TextBlock VerticalAlignment="Center" Margin="10 0 0 0">SAVE</TextBlock>
+                </StackPanel>
+            </Button>
+            
+        </DockPanel>
     </Grid>
 </UserControl>
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/packages.config b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/packages.config
index da5ed8abc..f9bce0fbf 100644
--- a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/packages.config
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/packages.config
@@ -6,6 +6,8 @@
   <package id="MahApps.Metro" version="1.5.0" targetFramework="net461" />
   <package id="MaterialDesignColors" version="1.1.2" targetFramework="net461" />
   <package id="MaterialDesignThemes" version="2.3.1.953" targetFramework="net461" />
+  <package id="Microsoft.WindowsAPICodePack-Core" version="1.1.0.0" targetFramework="net461" />
+  <package id="Microsoft.WindowsAPICodePack-Shell" version="1.1.0.0" targetFramework="net461" />
   <package id="Newtonsoft.Json" version="9.0.1" targetFramework="net461" />
   <package id="OxyPlot.Core" version="2.0.0" targetFramework="net461" />
   <package id="OxyPlot.Wpf" version="2.0.0" targetFramework="net461" />