Refactor for new graph calculation method

5 files changed, 284 insertions, 0 deletions

diff --git a/grapher/Models/Calculations/AccelCalculator.cs b/grapher/Models/Calculations/AccelCalculator.cs
index 2c32753..f59a0fa 100644
--- a/grapher/Models/Calculations/AccelCalculator.cs
+++ b/grapher/Models/Calculations/AccelCalculator.cs
@@ -14,12 +14,24 @@ namespace grapher.Models.Calculations
         {
             public double velocity;
             public double time;
+            public double angle;
             public int x;
             public int y;
         }
 
         #endregion Structs
 
+        #region Static
+
+        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, 
+        };
+
+        public IEnumerable<double> Angles = GetAngles();
+
+        #endregion static
+
         #region Constructors
 
         public AccelCalculator(Field dpi, Field pollRate)
@@ -58,6 +70,14 @@ namespace grapher.Models.Calculations
 
         #region Methods
 
+        public static IEnumerable<double> GetAngles()
+        {
+            for(int i=0; i<19; i++)
+            {
+                yield return (i / 18) * (Math.PI / 2);
+            }
+        }
+
         public void Calculate(AccelChartData data, ManagedAccel accel, double starter, ICollection<SimulatedMouseInput> simulatedInputData)
         {
             double lastInputMagnitude = 0;
@@ -316,6 +336,7 @@ namespace grapher.Models.Calculations
                     mouseInputData.y = j;
                     mouseInputData.time = MeasurementTime;
                     mouseInputData.velocity = Velocity(i, j, mouseInputData.time);
+                    mouseInputData.angle = Math.Atan2(j,i);
                     magnitudes.Add(mouseInputData);
                 }
             }
@@ -336,6 +357,7 @@ namespace grapher.Models.Calculations
                 mouseInputData.y = 0;
                 mouseInputData.time = MeasurementTime;
                 mouseInputData.velocity = Velocity(i, 0, mouseInputData.time);
+                mouseInputData.angle = 0;
                 magnitudes.Add(mouseInputData);
             }
 
@@ -353,12 +375,63 @@ namespace grapher.Models.Calculations
                 mouseInputData.y = i;
                 mouseInputData.time = MeasurementTime;
                 mouseInputData.velocity = Velocity(0, i, mouseInputData.time);
+                mouseInputData.angle = Math.PI / 2;
                 magnitudes.Add(mouseInputData);
             }
 
             return magnitudes.AsReadOnly();
         }
 
+        public ReadOnlyCollection<SimulatedMouseInput> GetSimulatedInputXY()
+        {
+            var magnitudes = new List<SimulatedMouseInput>();
+
+            foreach (var slowMoveMagnitude in SlowMovements)
+            {
+                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;
+
+                    SimulatedMouseInput mouseInputData;
+                    mouseInputData.x = ceilX;
+                    mouseInputData.y = ceilY;
+                    mouseInputData.time = timeFactor;
+                    mouseInputData.velocity = Velocity(ceilX, ceilY, timeFactor);
+                    mouseInputData.angle = slowAngle;
+                    magnitudes.Add(mouseInputData);
+                }
+            }
+
+            for (int magnitude = 5; magnitude < XYMaxVelocity; magnitude+=Increment)
+            {
+                foreach (var angle in Angles)
+                {
+                    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);
+                }
+            }
+
+            return magnitudes.AsReadOnly();
+        }
+
         public static double Magnitude(int x, int y)
         {
             return Math.Sqrt(x * x + y * y);
diff --git a/grapher/Models/Calculations/Data/AccelDataCombined.cs b/grapher/Models/Calculations/Data/AccelDataCombined.cs
new file mode 100644
index 0000000..8efb9ac
--- /dev/null
+++ b/grapher/Models/Calculations/Data/AccelDataCombined.cs
@@ -0,0 +1,49 @@
+using grapher.Models.Charts;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace grapher.Models.Calculations.Data
+{
+    public class AccelDataCombined : IAccelData
+    {
+        public AccelDataCombined(EstimatedPoints points, AccelCalculator calculator)
+        {
+            X = new AccelChartData();
+            Points = points;
+            Calculator = calculator;
+        }
+
+        public AccelChartData X { get; }
+
+        public AccelChartData Y { get => X; }
+
+        private EstimatedPoints Points { get; }
+
+        private AccelCalculator Calculator { get; }
+
+        public void CalculateDots(double x, double y, double timeInMs)
+        {
+            var outVelocity = AccelCalculator.Velocity(x, y, timeInMs);
+
+            (var inCombVel, var combSens, var combGain) = X.FindPointValuesFromOut(outVelocity);
+            Points.Velocity.Set(inCombVel, outVelocity);
+            Points.Sensitivity.Set(inCombVel, combSens);
+            Points.Gain.Set(inCombVel, combGain);
+
+        }
+
+        public void Clear()
+        {
+            X.Clear();
+        }
+
+        public void CreateGraphData(ManagedAccel accel, DriverSettings settings)
+        {
+            Clear();
+            Calculator.Calculate(X, accel, settings.sensitivity.x, Calculator.SimulatedInputCombined);
+        }
+    }
+}
diff --git a/grapher/Models/Calculations/Data/AccelDataXYComponential.cs b/grapher/Models/Calculations/Data/AccelDataXYComponential.cs
new file mode 100644
index 0000000..6231eb3
--- /dev/null
+++ b/grapher/Models/Calculations/Data/AccelDataXYComponential.cs
@@ -0,0 +1,64 @@
+using grapher.Models.Charts;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace grapher.Models.Calculations.Data
+{
+    public class AccelDataXYComponential : IAccelData
+    {
+        public AccelDataXYComponential(
+            EstimatedPoints xPoints,
+            EstimatedPoints yPoints,
+            AccelCalculator calculator)
+        {
+            X = new AccelChartData();
+            Y = new AccelChartData();
+            XPoints = xPoints;
+            YPoints = yPoints;
+            Calculator = calculator;
+        }
+
+        public AccelChartData X { get; }
+
+        public AccelChartData Y { get; }
+
+        private EstimatedPoints XPoints { get; }
+
+        private EstimatedPoints YPoints { get; }
+
+        private AccelCalculator Calculator { get; }
+
+        public void CalculateDots(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);
+            XPoints.Velocity.Set(inXVelocity, outX);
+            XPoints.Sensitivity.Set(inXVelocity, xSensitivity);
+            XPoints.Gain.Set(inXVelocity, xGain);
+
+            (var inYVelocity, var ySensitivity, var yGain) = Y.FindPointValuesFromOut(outY);
+            YPoints.Velocity.Set(inYVelocity, outY);
+            YPoints.Sensitivity.Set(inYVelocity, ySensitivity);
+            YPoints.Gain.Set(inYVelocity, yGain);
+
+        }
+
+        public void Clear()
+        {
+            X.Clear();
+            Y.Clear();
+        }
+
+        public void CreateGraphData(ManagedAccel accel, DriverSettings settings)
+        {
+            Clear();
+            Calculator.Calculate(X, accel, settings.sensitivity.x, Calculator.SimulatedInputX);
+            Calculator.Calculate(Y, accel, settings.sensitivity.y, Calculator.SimulatedInputY);
+        }
+    }
+}
diff --git a/grapher/Models/Calculations/Data/AccelDataXYDirectional.cs b/grapher/Models/Calculations/Data/AccelDataXYDirectional.cs
new file mode 100644
index 0000000..ffa353f
--- /dev/null
+++ b/grapher/Models/Calculations/Data/AccelDataXYDirectional.cs
@@ -0,0 +1,77 @@
+using grapher.Models.Charts;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace grapher.Models.Calculations.Data
+{
+    public class AccelDataXYDirectional : IAccelData
+    {
+        public AccelDataXYDirectional(
+            EstimatedPoints xPoints,
+            EstimatedPoints yPoints,
+            AccelCalculator calculator)
+        {
+            X = new AccelChartData();
+            Y = new AccelChartData();
+            XPoints = xPoints;
+            YPoints = yPoints;
+            Calculator = calculator;
+        }
+
+        public AccelChartData X { get; }
+
+        public AccelChartData Y { get; }
+
+        private EstimatedPoints XPoints { get; }
+
+        private EstimatedPoints YPoints { get; }
+
+        private AccelCalculator Calculator { get; }
+
+        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);
+            }
+
+        }
+
+        public void Clear()
+        {
+            X.Clear();
+            Y.Clear();
+        }
+
+        public void CreateGraphData(ManagedAccel accel, DriverSettings settings)
+        {
+            Clear();
+        }
+
+    }
+}
diff --git a/grapher/Models/Calculations/Data/IAccelData.cs b/grapher/Models/Calculations/Data/IAccelData.cs
new file mode 100644
index 0000000..576e6df
--- /dev/null
+++ b/grapher/Models/Calculations/Data/IAccelData.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace grapher.Models.Calculations.Data
+{
+    public interface IAccelData
+    {
+        void CalculateDots(double x, double y, double timeInMs);
+
+        void CreateGraphData(ManagedAccel accel, DriverSettings settings);
+
+        void Clear();
+
+        AccelChartData X { get; }
+
+        AccelChartData Y { get; }
+    }
+}