Directional works

11 files changed, 201 insertions, 361 deletions

diff --git a/grapher/Constants/Constants.cs b/grapher/Constants/Constants.cs
index 0fb9827..c76ac59 100644
--- a/grapher/Constants/Constants.cs
+++ b/grapher/Constants/Constants.cs
@@ -72,6 +72,9 @@ namespace grapher
 
         public const float SmallButtonSizeFactor = 0.666f;
 
+        /// <summary> Number of divisions between 0 and 90 degrees for directional lookup. For 19: 0, 5, 10... 85, 90.</summary>
+        public const int AngleDivisions = 19;
+
         /// <summary> Format string for shortened x and y textboxes. </summary>
         public const string ShortenedFormatString = "0.###";
 
diff --git a/grapher/Models/Calculations/AccelCalculator.cs b/grapher/Models/Calculations/AccelCalculator.cs
index f59a0fa..260d137 100644
--- a/grapher/Models/Calculations/AccelCalculator.cs
+++ b/grapher/Models/Calculations/AccelCalculator.cs
@@ -25,7 +25,7 @@ namespace grapher.Models.Calculations
 
         public static double[] SlowMovements =
         {
-            0,0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.333, 3.666, 4.0, 4.333, 4.666, 
+            0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.333, 3.666, 4.0, 4.333, 4.666, 
         };
 
         public IEnumerable<double> Angles = GetAngles();
@@ -50,6 +50,8 @@ namespace grapher.Models.Calculations
 
         public ReadOnlyCollection<SimulatedMouseInput> SimulatedInputY { get; private set; }
 
+        public IReadOnlyCollection<IReadOnlyCollection<SimulatedMouseInput>> SimulatedDirectionalInput { get; private set; }
+
         public Field DPI { get; private set; }
 
         public Field PollRate { get; private set; }
@@ -72,12 +74,18 @@ namespace grapher.Models.Calculations
 
         public static IEnumerable<double> GetAngles()
         {
-            for(int i=0; i<19; i++)
+            for(double i=0; i < (Constants.AngleDivisions); i++)
             {
-                yield return (i / 18) * (Math.PI / 2);
+                yield return (i / (Constants.AngleDivisions-1.0)) * (Math.PI / 2);
             }
         }
 
+        public static int NearestAngleDivision(double angle)
+        {
+            var angleTransformed = angle * 2 / Math.PI * (Constants.AngleDivisions-1);
+            return (int)Math.Round(angleTransformed);
+        }
+
         public void Calculate(AccelChartData data, ManagedAccel accel, double starter, ICollection<SimulatedMouseInput> simulatedInputData)
         {
             double lastInputMagnitude = 0;
@@ -174,12 +182,8 @@ namespace grapher.Models.Calculations
             data.MinGain = minSlope;
         }
 
-        public void CalculateCombinedDiffSens(AccelData data, ManagedAccel accel, DriverSettings settings, ICollection<SimulatedMouseInput> simulatedInputData)
+        public void CalculateCombinedDiffSens(AccelChartData[] dataByAngle, ManagedAccel accel, DriverSettings settings, IReadOnlyCollection<IReadOnlyCollection<SimulatedMouseInput>> simulatedInputData)
         {
-            double lastInputMagnitude = 0;
-            double lastOutputMagnitudeX = 0;
-            double lastOutputMagnitudeY = 0;
-
             double maxRatio = 0.0;
             double minRatio = Double.MaxValue;
             double maxSlope = 0.0;
@@ -188,140 +192,101 @@ namespace grapher.Models.Calculations
 
             Sensitivity = GetSens(ref settings);
 
-            double log = -2;
-            int index = 0;
-            int logIndex = 0;
+            int angleIndex = 0;
 
-            foreach (var simulatedInputDatum in simulatedInputData)
+            foreach (var simulatedInputDataAngle in simulatedInputData)
             {
-                if (simulatedInputDatum.velocity <= 0)
-                {
-                    continue;
-                }
-
-                var output = accel.Accelerate(simulatedInputDatum.x, simulatedInputDatum.y, simulatedInputDatum.time);
-                var outputWithoutSens = StripThisSens(output.Item1, output.Item2);
-                var magnitudeWithoutSens = Velocity(outputWithoutSens.Item1, outputWithoutSens.Item2, simulatedInputDatum.time);
+                double log = -2;
+                int index = 0;
+                int logIndex = 0;
+                double lastInputMagnitude = 0;
+                double lastOutputMagnitude = 0;
 
-                var ratio = magnitudeWithoutSens / simulatedInputDatum.velocity;
+                var data = dataByAngle[angleIndex];
 
-                if (!data.Combined.VelocityPoints.ContainsKey(simulatedInputDatum.velocity))
+                foreach (var simulatedInputDatum in simulatedInputDataAngle)
                 {
-                    data.Combined.VelocityPoints.Add(simulatedInputDatum.velocity, magnitudeWithoutSens);
-                }
-                else
-                {
-                    continue;
+                    if (simulatedInputDatum.velocity <= 0)
+                    {
+                        continue;
+                    }
+
+                    var output = accel.Accelerate(simulatedInputDatum.x, simulatedInputDatum.y, simulatedInputDatum.time);
+                    var magnitude = Velocity(output.Item1, output.Item2, simulatedInputDatum.time);
+
+                    var ratio = magnitude / simulatedInputDatum.velocity;
+
+                    if (!data.VelocityPoints.ContainsKey(simulatedInputDatum.velocity))
+                    {
+                        data.VelocityPoints.Add(simulatedInputDatum.velocity, magnitude);
+                    }
+                    else
+                    {
+                        continue;
+                    }
+
+                    while (Math.Pow(10, log) < magnitude && logIndex < data.LogToIndex.Length)
+                    {
+                        data.LogToIndex[logIndex] = index;
+                        log += 0.01;
+                        logIndex++;
+                    }
+
+                    if (ratio > maxRatio)
+                    {
+                        maxRatio = ratio;
+                    }
+
+                    if (ratio < minRatio)
+                    {
+                        minRatio = ratio;
+                    }
+
+                    var inDiff = simulatedInputDatum.velocity - lastInputMagnitude;
+                    var outDiff = magnitude - lastOutputMagnitude;
+                    var slope = inDiff > 0 ? outDiff / inDiff : settings.sensitivity.x;
+
+                    if (slope > maxSlope)
+                    {
+                        maxSlope = slope;
+                    }
+
+                    if (slope < minSlope)
+                    {
+                        minSlope = slope;
+                    }
+
+                    if (!data.AccelPoints.ContainsKey(simulatedInputDatum.velocity))
+                    {
+                        data.AccelPoints.Add(simulatedInputDatum.velocity, ratio);
+                    }
+
+                    if (!data.GainPoints.ContainsKey(simulatedInputDatum.velocity))
+                    {
+                        data.GainPoints.Add(simulatedInputDatum.velocity, slope);
+                    }
+
+                    lastInputMagnitude = simulatedInputDatum.velocity;
+                    lastOutputMagnitude = magnitude;
+                    index += 1;
                 }
 
-                while (Math.Pow(10,log) < magnitudeWithoutSens && logIndex < data.Combined.LogToIndex.Length)
+                index--;
+
+                while (log <= 5.0)
                 {
-                    data.Combined.LogToIndex[logIndex] = index;
+                    data.LogToIndex[logIndex] = index;
                     log += 0.01;
                     logIndex++;
                 }
 
-                var xRatio = settings.sensitivity.x * ratio;
-                var yRatio = settings.sensitivity.y * ratio;
-
-                if (xRatio > maxRatio)
-                {
-                    maxRatio = xRatio;
-                }
-
-                if (xRatio < minRatio)
-                {
-                    minRatio = xRatio;
-                }
-
-                if (yRatio > maxRatio)
-                {
-                    maxRatio = yRatio;
-                }
-
-                if (yRatio < minRatio)
-                {
-                    minRatio = yRatio;
-                }
-
-                if (!data.X.AccelPoints.ContainsKey(simulatedInputDatum.velocity))
-                {
-                    data.X.AccelPoints.Add(simulatedInputDatum.velocity, xRatio);
-                }
-
-                if (!data.Y.AccelPoints.ContainsKey(simulatedInputDatum.velocity))
-                {
-                    data.Y.AccelPoints.Add(simulatedInputDatum.velocity, yRatio);
-                }
-
-                var xOut = xRatio * simulatedInputDatum.velocity;
-                var yOut = yRatio * simulatedInputDatum.velocity;
-
-                var inDiff = simulatedInputDatum.velocity - lastInputMagnitude;
-                var xOutDiff = xOut - lastOutputMagnitudeX;
-                var yOutDiff = yOut - lastOutputMagnitudeY;
-                var xSlope = inDiff > 0 ? xOutDiff / inDiff : settings.sensitivity.x;
-                var ySlope = inDiff > 0 ? yOutDiff / inDiff : settings.sensitivity.y;
-
-                if (xSlope > maxSlope)
-                {
-                    maxSlope = xSlope;
-                }
-
-                if (xSlope < minSlope)
-                {
-                    minSlope = xSlope;
-                }
-
-                if (ySlope > maxSlope)
-                {
-                    maxSlope = ySlope;
-                }
-
-                if (ySlope < minSlope)
-                {
-                    minSlope = ySlope;
-                }
-
-                if (!data.X.VelocityPoints.ContainsKey(simulatedInputDatum.velocity))
-                {
-                    data.X.VelocityPoints.Add(simulatedInputDatum.velocity, xOut);
-                }
-
-                if (!data.Y.VelocityPoints.ContainsKey(simulatedInputDatum.velocity))
-                {
-                    data.Y.VelocityPoints.Add(simulatedInputDatum.velocity, yOut);
-                }
-
-                if (!data.X.GainPoints.ContainsKey(simulatedInputDatum.velocity))
-                {
-                    data.X.GainPoints.Add(simulatedInputDatum.velocity, xSlope);
-                }
-
-                if (!data.Y.GainPoints.ContainsKey(simulatedInputDatum.velocity))
-                {
-                    data.Y.GainPoints.Add(simulatedInputDatum.velocity, ySlope);
-                }
-
-                lastInputMagnitude = simulatedInputDatum.velocity;
-                lastOutputMagnitudeX = xOut;
-                lastOutputMagnitudeY = yOut;
-                index += 1;
+                angleIndex++;
             }
 
-            index--;
-
-            while (log <= 5.0)
-            {
-                data.Combined.LogToIndex[logIndex] = index;
-                log += 0.01;
-                logIndex++;
-            }
-
-            data.Combined.MaxAccel = maxRatio;
-            data.Combined.MinAccel = minRatio;
-            data.Combined.MaxGain = maxSlope;
-            data.Combined.MinGain = minSlope;
+            dataByAngle[0].MaxAccel = maxRatio;
+            dataByAngle[0].MinAccel = minRatio;
+            dataByAngle[0].MaxGain = maxSlope;
+            dataByAngle[0].MinGain = minSlope;
         }
 
         public ReadOnlyCollection<SimulatedMouseInput> GetSimulatedInput()
@@ -382,54 +347,56 @@ namespace grapher.Models.Calculations
             return magnitudes.AsReadOnly();
         }
 
-        public ReadOnlyCollection<SimulatedMouseInput> GetSimulatedInputXY()
+        public IReadOnlyCollection<IReadOnlyCollection<SimulatedMouseInput>> GetSimulatedDirectionalInput()
         {
-            var magnitudes = new List<SimulatedMouseInput>();
+            var magnitudesByAngle = new List<IReadOnlyCollection<SimulatedMouseInput>>();
 
-            foreach (var slowMoveMagnitude in SlowMovements)
+            foreach (var angle in Angles)
             {
-                foreach (var slowAngle in Angles)
-                {
-                    var slowMoveX = slowMoveMagnitude * Math.Cos(slowAngle);
-                    var slowMoveY = slowMoveMagnitude * Math.Sin(slowAngle);
-                    var ceilX = (int)Math.Ceiling(slowMoveX);
-                    var ceilY = (int)Math.Ceiling(slowMoveY);
-                    var magnitude = Magnitude(slowMoveX, slowMoveY);
-                    var ceilMagnitude = Magnitude(ceilX, ceilY);
-                    var timeFactor = ceilMagnitude / magnitude;
+                var magnitudes = new List<SimulatedMouseInput>();
 
-                    SimulatedMouseInput mouseInputData;
-                    mouseInputData.x = ceilX;
-                    mouseInputData.y = ceilY;
-                    mouseInputData.time = timeFactor;
-                    mouseInputData.velocity = Velocity(ceilX, ceilY, timeFactor);
-                    mouseInputData.angle = slowAngle;
-                    magnitudes.Add(mouseInputData);
+                foreach (var slowMoveMagnitude in SlowMovements)
+                {
+                        var slowMoveX = Math.Round(slowMoveMagnitude * Math.Cos(angle), 4);
+                        var slowMoveY = Math.Round(slowMoveMagnitude * Math.Sin(angle), 4);
+                        var ratio = slowMoveX > 0.0 ? slowMoveY / slowMoveX : 90;
+                        var ceilX = (int)Math.Round(slowMoveX*90);
+                        var ceilY = (int)Math.Round(slowMoveY*ratio);
+                        var ceilMagnitude = Magnitude(ceilX, ceilY);
+                        var timeFactor = ceilMagnitude / slowMoveMagnitude;
+
+                        SimulatedMouseInput mouseInputData;
+                        mouseInputData.x = ceilX;
+                        mouseInputData.y = ceilY;
+                        mouseInputData.time = timeFactor;
+                        mouseInputData.velocity = Velocity(ceilX, ceilY, timeFactor);
+                        mouseInputData.angle = angle;
+                        magnitudes.Add(mouseInputData);
                 }
-            }
 
-            for (int magnitude = 5; magnitude < XYMaxVelocity; magnitude+=Increment)
-            {
-                foreach (var angle in Angles)
+                for (int magnitude = 5; magnitude < XYMaxVelocity; magnitude+=Increment)
                 {
-                    var slowMoveX = magnitude * Math.Cos(angle);
-                    var slowMoveY = magnitude * Math.Sin(angle);
-                    var ceilX = (int)Math.Ceiling(slowMoveX);
-                    var ceilY = (int)Math.Ceiling(slowMoveY);
-                    var ceilMagnitude = Magnitude(ceilX, ceilY);
-                    var timeFactor = ceilMagnitude / magnitude;
-
-                    SimulatedMouseInput mouseInputData;
-                    mouseInputData.x =ceilX;
-                    mouseInputData.y = ceilY;
-                    mouseInputData.time = MeasurementTime;
-                    mouseInputData.velocity = Velocity(ceilX, ceilY, mouseInputData.time);
-                    mouseInputData.angle = angle;
-                    magnitudes.Add(mouseInputData);
+                        var slowMoveX = Math.Round(magnitude * Math.Cos(angle), 4);
+                        var slowMoveY = Math.Round(magnitude * Math.Sin(angle), 4);
+                        var ratio = slowMoveX > 0.0 ? slowMoveY / slowMoveX : 90;
+                        var ceilX = (int)Math.Round(slowMoveX*90);
+                        var ceilY = (int)Math.Round(slowMoveY*ratio);
+                        var ceilMagnitude = Magnitude(ceilX, ceilY);
+                        var timeFactor = ceilMagnitude / magnitude;
+
+                        SimulatedMouseInput mouseInputData;
+                        mouseInputData.x = ceilX;
+                        mouseInputData.y = ceilY;
+                        mouseInputData.time = timeFactor;
+                        mouseInputData.velocity = Velocity(ceilX, ceilY, mouseInputData.time);
+                        mouseInputData.angle = angle;
+                        magnitudes.Add(mouseInputData);
                 }
+
+                magnitudesByAngle.Add(magnitudes.AsReadOnly());
             }
 
-            return magnitudes.AsReadOnly();
+            return magnitudesByAngle.AsReadOnly();
         }
 
         public static double Magnitude(int x, int y)
@@ -487,6 +454,7 @@ namespace grapher.Models.Calculations
             SimulatedInputCombined = GetSimulatedInput();
             SimulatedInputX = GetSimulatInputX();
             SimulatedInputY = GetSimulatedInputY();
+            SimulatedDirectionalInput = GetSimulatedDirectionalInput();
         }
 
         #endregion Methods
diff --git a/grapher/Models/Calculations/AccelData.cs b/grapher/Models/Calculations/AccelData.cs
deleted file mode 100644
index d35217f..0000000
--- a/grapher/Models/Calculations/AccelData.cs
+++ /dev/null
@@ -1,117 +0,0 @@
-using grapher.Models.Charts;
-using grapher.Models.Serialized;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace grapher.Models.Calculations
-{
-    public class AccelData
-    {
-        #region Constructors
-
-        public AccelData(
-            EstimatedPoints combined,
-            EstimatedPoints x,
-            EstimatedPoints y)
-        {
-            Combined = new AccelChartData();
-            X = new AccelChartData();
-            Y = new AccelChartData();
-
-            Estimated = combined;
-            EstimatedX = x;
-            EstimatedY = y;
-
-            OutVelocityToPoints = new Dictionary<double, (double, double, double, double, double, double, double)>();
-        }
-
-        #endregion Constructors
-
-        #region Properties
-
-        public AccelChartData Combined { get; }
-
-        public AccelChartData X { get; }
-
-        public AccelChartData Y { get; }
-
-        private EstimatedPoints Estimated { get; }
-
-        private EstimatedPoints EstimatedX { get; }
-
-        private EstimatedPoints EstimatedY { get; }
-
-        private Dictionary<double, (double, double, double, double, double, double, double)> OutVelocityToPoints { get; }
-
-        #endregion Properties
-
-        #region Methods
-
-        public void Clear()
-        {
-            Combined.Clear();
-            X.Clear();
-            Y.Clear();
-            OutVelocityToPoints.Clear();
-        }
-
-        public void CalculateDots(double x, double y, double timeInMs)
-        {
-            var outVelocity = AccelCalculator.Velocity(x, y, timeInMs);
-
-            (var inCombVel, var combSens, var combGain) = Combined.FindPointValuesFromOut(outVelocity);
-            Estimated.Velocity.Set(inCombVel, outVelocity);
-            Estimated.Sensitivity.Set(inCombVel, combSens);
-            Estimated.Gain.Set(inCombVel, combGain);
-        }
-
-        public void CalculateDotsXY(double x, double y, double timeInMs)
-        {
-            var outX = Math.Abs(x) / timeInMs;
-            var outY = Math.Abs(y) / timeInMs;
-
-            (var inXVelocity, var xSensitivity, var xGain) = X.FindPointValuesFromOut(outX);
-            EstimatedX.Velocity.Set(inXVelocity, outX);
-            EstimatedX.Sensitivity.Set(inXVelocity, xSensitivity);
-            EstimatedX.Gain.Set(inXVelocity, xGain);
-
-            (var inYVelocity, var ySensitivity, var yGain) = Y.FindPointValuesFromOut(outY);
-            EstimatedY.Velocity.Set(inYVelocity, outY);
-            EstimatedY.Sensitivity.Set(inYVelocity, ySensitivity);
-            EstimatedY.Gain.Set(inYVelocity, yGain);
-        }
-
-        public void CalculateDotsCombinedDiffSens(double x, double y, double timeInMs, DriverSettings settings)
-        {
-            (var xStripped, var yStripped) = AccelCalculator.StripSens(x, y, settings.sensitivity.x, settings.sensitivity.y);
-            var outVelocity = AccelCalculator.Velocity(xStripped, yStripped, timeInMs);
-
-            if (OutVelocityToPoints.TryGetValue(outVelocity, out var points))
-            {
-                EstimatedX.Sensitivity.Set(points.Item1, points.Item2);
-                EstimatedX.Velocity.Set(points.Item1, points.Item3);
-                EstimatedX.Gain.Set(points.Item1, points.Item4);
-                EstimatedY.Sensitivity.Set(points.Item1, points.Item5);
-                EstimatedY.Velocity.Set(points.Item1, points.Item6);
-                EstimatedY.Gain.Set(points.Item1, points.Item7);
-            }
-            else
-            {
-                var index = Combined.GetVelocityIndex(outVelocity);
-                var inVelocity = Combined.VelocityPoints.ElementAt(index).Key;
-                var xPoints = X.ValuesAtIndex(index);
-                var yPoints = Y.ValuesAtIndex(index);
-                OutVelocityToPoints.Add(outVelocity, (inVelocity, xPoints.Item1, xPoints.Item2, xPoints.Item3, yPoints.Item1, yPoints.Item2, yPoints.Item3));
-                EstimatedX.Sensitivity.Set(inVelocity, xPoints.Item1);
-                EstimatedX.Velocity.Set(inVelocity, xPoints.Item2);
-                EstimatedX.Gain.Set(inVelocity, xPoints.Item3);
-                EstimatedY.Sensitivity.Set(inVelocity, yPoints.Item1);
-                EstimatedY.Velocity.Set(inVelocity, yPoints.Item2);
-                EstimatedY.Gain.Set(inVelocity, yPoints.Item3);
-            }
-        }
-
-        #endregion Methods
-    }
-}
diff --git a/grapher/Models/Calculations/Data/AccelDataXYDirectional.cs b/grapher/Models/Calculations/Data/AccelDataXYDirectional.cs
index ffa353f..ad54989 100644
--- a/grapher/Models/Calculations/Data/AccelDataXYDirectional.cs
+++ b/grapher/Models/Calculations/Data/AccelDataXYDirectional.cs
@@ -14,16 +14,26 @@ namespace grapher.Models.Calculations.Data
             EstimatedPoints yPoints,
             AccelCalculator calculator)
         {
-            X = new AccelChartData();
-            Y = new AccelChartData();
             XPoints = xPoints;
             YPoints = yPoints;
             Calculator = calculator;
+            AngleToData = new AccelChartData[Constants.AngleDivisions];
+            FillAngleData();
         }
 
-        public AccelChartData X { get; }
+        public AccelChartData X { get => AngleToData[0]; }
 
-        public AccelChartData Y { get; }
+        public AccelChartData Y { get => AngleToData[Constants.AngleDivisions-1]; }
+
+        public double SensitivityMax { get => X.MaxAccel; }
+
+        public double SensitivityMin { get => X.MinAccel; }
+
+        public double GainMax { get => X.MaxGain; }
+
+        public double GainMin { get => X.MinGain; }
+
+        private AccelChartData[] AngleToData { get; }
 
         private EstimatedPoints XPoints { get; }
 
@@ -33,45 +43,42 @@ namespace grapher.Models.Calculations.Data
 
         public void CalculateDots(double x, double y, double timeInMs)
         {
-            (var xStripped, var yStripped) = AccelCalculator.StripSens(x, y, settings.sensitivity.x, settings.sensitivity.y);
-            var outVelocity = AccelCalculator.Velocity(xStripped, yStripped, timeInMs);
-
-            if (OutVelocityToPoints.TryGetValue(outVelocity, out var points))
-            {
-                XPoints.Sensitivity.Set(points.Item1, points.Item2);
-                XPoints.Velocity.Set(points.Item1, points.Item3);
-                XPoints.Gain.Set(points.Item1, points.Item4);
-                YPoints.Sensitivity.Set(points.Item1, points.Item5);
-                YPoints.Velocity.Set(points.Item1, points.Item6);
-                YPoints.Gain.Set(points.Item1, points.Item7);
-            }
-            else
-            {
-                var index = Combined.GetVelocityIndex(outVelocity);
-                var inVelocity = Combined.VelocityPoints.ElementAt(index).Key;
-                var xPoints = X.ValuesAtIndex(index);
-                var yPoints = Y.ValuesAtIndex(index);
-                OutVelocityToPoints.Add(outVelocity, (inVelocity, xPoints.Item1, xPoints.Item2, xPoints.Item3, yPoints.Item1, yPoints.Item2, yPoints.Item3));
-                EstimatedX.Sensitivity.Set(inVelocity, xPoints.Item1);
-                EstimatedX.Velocity.Set(inVelocity, xPoints.Item2);
-                EstimatedX.Gain.Set(inVelocity, xPoints.Item3);
-                EstimatedY.Sensitivity.Set(inVelocity, yPoints.Item1);
-                EstimatedY.Velocity.Set(inVelocity, yPoints.Item2);
-                EstimatedY.Gain.Set(inVelocity, yPoints.Item3);
-            }
-
+            var outVelocity = AccelCalculator.Velocity(x, y, timeInMs);
+            var outAngle = Math.Atan2(Math.Abs(y),Math.Abs(x));
+            var nearestAngleDivision = AccelCalculator.NearestAngleDivision(outAngle);
+            var data = AngleToData[nearestAngleDivision];
+            var index = data.GetVelocityIndex(outVelocity);
+            var inVelocity = data.VelocityPoints.ElementAt(index).Key;
+            var xPoints = X.ValuesAtIndex(index);
+            var yPoints = Y.ValuesAtIndex(index);
+            XPoints.Sensitivity.Set(inVelocity, xPoints.Item1);
+            XPoints.Velocity.Set(inVelocity, xPoints.Item2);
+            XPoints.Gain.Set(inVelocity, xPoints.Item3);
+            YPoints.Sensitivity.Set(inVelocity, yPoints.Item1);
+            YPoints.Velocity.Set(inVelocity, yPoints.Item2);
+            YPoints.Gain.Set(inVelocity, yPoints.Item3);
         }
 
         public void Clear()
         {
-            X.Clear();
-            Y.Clear();
+            foreach (var data in AngleToData)
+            {
+                data.Clear();
+            }
         }
 
         public void CreateGraphData(ManagedAccel accel, DriverSettings settings)
         {
             Clear();
+            Calculator.CalculateCombinedDiffSens(AngleToData, accel, settings, Calculator.SimulatedDirectionalInput);
         }
 
+        private void FillAngleData()
+        {
+            for(int i=0; i < Constants.AngleDivisions; i++)
+            {
+                AngleToData[i] = new AccelChartData();
+            }
+        }
     }
 }
diff --git a/grapher/Models/Charts/AccelCharts.cs b/grapher/Models/Charts/AccelCharts.cs
index b9f7a8b..2369432 100644
--- a/grapher/Models/Charts/AccelCharts.cs
+++ b/grapher/Models/Charts/AccelCharts.cs
@@ -2,9 +2,7 @@
 using grapher.Models.Calculations.Data;
 using grapher.Models.Charts;
 using grapher.Models.Charts.ChartState;
-using grapher.Models.Serialized;
 using System;
-using System.Drawing;
 using System.Windows.Forms;
 
 namespace grapher
@@ -27,7 +25,14 @@ namespace grapher
             var estimatedX = new EstimatedPoints();
             var estimatedY = new EstimatedPoints();
             SetupCharts(sensitivityChart, velocityChart, gainChart, estimated, estimatedX, estimatedY);
-            ChartStateManager = new ChartStateManager(sensitivityChart, velocityChart, gainChart, accelData, accelCalculator);
+            ChartStateManager = new ChartStateManager(
+                sensitivityChart,
+                velocityChart,
+                gainChart,
+                accelCalculator,
+                estimated,
+                estimatedY,
+                estimatedX);
 
             ContainingForm = form;
             EnableVelocityAndGain = enableVelocityAndGain;
diff --git a/grapher/Models/Charts/ChartState/ChartState.cs b/grapher/Models/Charts/ChartState/ChartState.cs
index 2a0325c..5a86713 100644
--- a/grapher/Models/Charts/ChartState/ChartState.cs
+++ b/grapher/Models/Charts/ChartState/ChartState.cs
@@ -39,13 +39,19 @@ namespace grapher.Models.Charts.ChartState
 
         internal bool TwoDotsPerGraph { get; set; }
 
-        public abstract void MakeDots(double x, double y, double timeInMs);
+        public virtual void MakeDots(double x, double y, double timeInMs)
+        {
+            Data.CalculateDots(x, y, timeInMs);
+        }
 
         public abstract void Bind();
 
         public abstract void Activate();
 
-        public abstract void Calculate(ManagedAccel accel, DriverSettings settings);
+        public virtual void Calculate(ManagedAccel accel, DriverSettings settings)
+        {
+            Data.CreateGraphData(accel, settings);
+        }
 
         public void Redraw()
         {
diff --git a/grapher/Models/Charts/ChartState/ChartStateManager.cs b/grapher/Models/Charts/ChartState/ChartStateManager.cs
index 9ed54e1..3d4bbec 100644
--- a/grapher/Models/Charts/ChartState/ChartStateManager.cs
+++ b/grapher/Models/Charts/ChartState/ChartStateManager.cs
@@ -38,7 +38,8 @@ namespace grapher.Models.Charts.ChartState
                 sensitivityChart,
                 velocityChart,
                 gainChat,
-                accelData,
+                xPoints,
+                yPoints,
                 accelCalculator);
         }
 
diff --git a/grapher/Models/Charts/ChartState/CombinedState.cs b/grapher/Models/Charts/ChartState/CombinedState.cs
index 7275d16..3511cec 100644
--- a/grapher/Models/Charts/ChartState/CombinedState.cs
+++ b/grapher/Models/Charts/ChartState/CombinedState.cs
@@ -32,11 +32,6 @@ namespace grapher.Models.Charts.ChartState
             GainChart.ClearSecondDots();
         }
 
-        public override void MakeDots(double x, double y, double timeInMs)
-        {
-            Data.CalculateDots(x, y, timeInMs);
-        }
-
         public override void Bind()
         {
             SensitivityChart.Bind(Data.X.AccelPoints);
@@ -45,10 +40,5 @@ namespace grapher.Models.Charts.ChartState
             SensitivityChart.SetMinMax(Data.X.MinAccel, Data.X.MaxAccel);
             GainChart.SetMinMax(Data.X.MinGain, Data.X.MaxGain);
         }
-
-        public override void Calculate(ManagedAccel accel, DriverSettings settings)
-        {
-            Calculator.Calculate(Data.X, accel, settings.sensitivity.x, Calculator.SimulatedInputCombined);
-        }
     }
 }
diff --git a/grapher/Models/Charts/ChartState/XYOneGraphState.cs b/grapher/Models/Charts/ChartState/XYOneGraphState.cs
index 14d8850..34e9070 100644
--- a/grapher/Models/Charts/ChartState/XYOneGraphState.cs
+++ b/grapher/Models/Charts/ChartState/XYOneGraphState.cs
@@ -19,10 +19,13 @@ namespace grapher.Models.Charts.ChartState
                   gainChart,
                   accelCalculator)
         {
-            Data = new AccelDataXYDirectional(xPoints, yPoints, accelCalculator);
+            DataDirectional  = new AccelDataXYDirectional(xPoints, yPoints, accelCalculator);
+            Data = DataDirectional;
             TwoDotsPerGraph = true;
         }
 
+        private AccelDataXYDirectional DataDirectional { get; }
+
         public override void Activate()
         {
             SensitivityChart.SetCombined();
@@ -30,27 +33,13 @@ namespace grapher.Models.Charts.ChartState
             GainChart.SetCombined();
         }
 
-        public override void MakeDots(double x, double y, double timeInMs)
-        {
-            Data.CalculateDots(x, y, timeInMs);
-        }
-
         public override void Bind()
         {
             SensitivityChart.BindXYCombined(Data.X.AccelPoints, Data.Y.AccelPoints);
             VelocityChart.BindXYCombined(Data.X.VelocityPoints, Data.Y.VelocityPoints);
             GainChart.BindXYCombined(Data.X.GainPoints, Data.Y.GainPoints);
-            SensitivityChart.SetMinMax(Data.Combined.MinAccel, Data.Combined.MaxAccel);
-            GainChart.SetMinMax(Data.Combined.MinGain, Data.Combined.MaxGain);
-        }
-
-        public override void Calculate(ManagedAccel accel, DriverSettings settings)
-        {
-            Calculator.CalculateCombinedDiffSens(Data, accel, settings, Calculator.SimulatedInputCombined);
-            Data.X.Clear();
-            Data.Y.Clear();
-            Calculator.Calculate(Data.X, accel, settings.sensitivity.x, Calculator.SimulatedInputX);
-            Calculator.Calculate(Data.Y, accel, settings.sensitivity.y, Calculator.SimulatedInputY);
+            SensitivityChart.SetMinMax(DataDirectional.SensitivityMin, DataDirectional.SensitivityMax);
+            GainChart.SetMinMax(DataDirectional.GainMin, DataDirectional.GainMax);
         }
     }
 }
diff --git a/grapher/Models/Charts/ChartState/XYTwoGraphState.cs b/grapher/Models/Charts/ChartState/XYTwoGraphState.cs
index 7dc2810..5b6c2b8 100644
--- a/grapher/Models/Charts/ChartState/XYTwoGraphState.cs
+++ b/grapher/Models/Charts/ChartState/XYTwoGraphState.cs
@@ -36,11 +36,6 @@ namespace grapher.Models.Charts.ChartState
             GainChart.ClearSecondDots();
         }
 
-        public override void MakeDots(double x, double y, double timeInMs)
-        {
-            Data.CalculateDots(x, y, timeInMs);
-        }
-
         public override void Bind()
         {
             SensitivityChart.BindXY(Data.X.AccelPoints, Data.Y.AccelPoints);
@@ -50,11 +45,5 @@ namespace grapher.Models.Charts.ChartState
             SensitivityChart.SetMinMaxXY(Data.X.MinAccel, Data.X.MaxAccel, Data.Y.MinAccel, Data.Y.MaxAccel);
             GainChart.SetMinMaxXY(Data.X.MinGain, Data.X.MaxGain, Data.Y.MinGain, Data.Y.MaxGain);
         }
-
-        public override void Calculate(ManagedAccel accel, DriverSettings settings)
-        {
-            Calculator.Calculate(Data.X, accel, settings.sensitivity.x, Calculator.SimulatedInputX);
-            Calculator.Calculate(Data.Y, accel, settings.sensitivity.y, Calculator.SimulatedInputY);
-        }
     }
 }
diff --git a/grapher/grapher.csproj b/grapher/grapher.csproj
index 0216b8b..88e7752 100644
--- a/grapher/grapher.csproj
+++ b/grapher/grapher.csproj
@@ -83,7 +83,6 @@
     <Compile Include="Models\AccelGUIFactory.cs" />
     <Compile Include="Models\Calculations\AccelCalculator.cs" />
     <Compile Include="Models\Calculations\AccelChartData.cs" />
-    <Compile Include="Models\Calculations\AccelData.cs" />
     <Compile Include="Models\Calculations\Data\AccelDataCombined.cs" />
     <Compile Include="Models\Calculations\Data\AccelDataXYComponential.cs" />
     <Compile Include="Models\Calculations\Data\AccelDataXYDirectional.cs" />