Merge branch 'GUI' into experiment

3 files changed, 167 insertions, 23 deletions

diff --git a/grapher/Models/Calculations/AccelCalculator.cs b/grapher/Models/Calculations/AccelCalculator.cs
index 7293681..8865939 100644
--- a/grapher/Models/Calculations/AccelCalculator.cs
+++ b/grapher/Models/Calculations/AccelCalculator.cs
@@ -49,20 +49,13 @@ namespace grapher.Models.Calculations
         
         private double MeasurementTime { get; set; }
 
-        #endregion Fields
-
-        #region Methods
+        private (double, double) RotationVector { get; set; } 
 
-        public void Calculate(AccelData data, ManagedAccel accel, DriverSettings settings)
-        {
-            ScaleByMouseSettings();
+        private (double, double) Sensitivity { get; set; }
 
-            data.Clear();
+        #endregion Fields
 
-            Calculate(data.Combined, accel, settings.sensitivity.x, MagnitudesCombined);
-            Calculate(data.X, accel, settings.sensitivity.x, MagnitudesX);
-            Calculate(data.Y, accel, settings.sensitivity.y, MagnitudesY);
-        }
+        #region Methods
 
         public void Calculate(AccelChartData data, ManagedAccel accel, double starter, ICollection<MagnitudeData> magnitudeData)
         {
@@ -72,7 +65,6 @@ namespace grapher.Models.Calculations
             foreach (var magnitudeDatum in magnitudeData)
             {
                 var output = accel.Accelerate(magnitudeDatum.x, magnitudeDatum.y, MeasurementTime);
-
                 var outMagnitude = Magnitude(output.Item1, output.Item2);
 
                 var ratio = magnitudeDatum.magnitude > 0 ? outMagnitude / magnitudeDatum.magnitude : starter;
@@ -103,6 +95,77 @@ namespace grapher.Models.Calculations
             data.OrderedVelocityPointsList.AddRange(data.VelocityPoints.Values.ToList());
         }
 
+        public void CalculateCombinedDiffSens(AccelData data, ManagedAccel accel, DriverSettings settings, ICollection<MagnitudeData> magnitudeData)
+        {
+            double lastInputMagnitude = 0;
+            double lastOutputMagnitudeX = 0;
+            double lastOutputMagnitudeY = 0;
+
+            Sensitivity = GetSens(ref settings);
+
+            foreach (var magnitudeDatum in magnitudeData)
+            {
+                var output = accel.Accelerate(magnitudeDatum.x, magnitudeDatum.y, MeasurementTime);
+                var outputWithoutSens = StripThisSens(output.Item1, output.Item2);
+                var magnitudeWithoutSens = Magnitude(outputWithoutSens.Item1, outputWithoutSens.Item2);
+
+                var ratio = magnitudeDatum.magnitude > 0 ? magnitudeWithoutSens / magnitudeDatum.magnitude : 1;
+
+                if (!data.Combined.VelocityPoints.ContainsKey(magnitudeDatum.magnitude))
+                {
+                    data.Combined.VelocityPoints.Add(magnitudeDatum.magnitude, magnitudeWithoutSens);
+                }
+
+                var xRatio = settings.sensitivity.x * ratio;
+                var yRatio = settings.sensitivity.y * ratio;
+
+                if (!data.X.AccelPoints.ContainsKey(magnitudeDatum.magnitude))
+                {
+                    data.X.AccelPoints.Add(magnitudeDatum.magnitude, xRatio);
+                }
+
+                if (!data.Y.AccelPoints.ContainsKey(magnitudeDatum.magnitude))
+                {
+                    data.Y.AccelPoints.Add(magnitudeDatum.magnitude, yRatio);
+                }
+
+                var xOut = xRatio * magnitudeDatum.magnitude;
+                var yOut = yRatio * magnitudeDatum.magnitude;
+
+                var inDiff = magnitudeDatum.magnitude - 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 (!data.X.VelocityPoints.ContainsKey(magnitudeDatum.magnitude))
+                {
+                    data.X.VelocityPoints.Add(magnitudeDatum.magnitude, xOut);
+                }
+
+                if (!data.Y.VelocityPoints.ContainsKey(magnitudeDatum.magnitude))
+                {
+                    data.Y.VelocityPoints.Add(magnitudeDatum.magnitude, yOut);
+                }
+
+                if (!data.X.GainPoints.ContainsKey(magnitudeDatum.magnitude))
+                {
+                    data.X.GainPoints.Add(magnitudeDatum.magnitude, xSlope);
+                }
+
+                if (!data.Y.GainPoints.ContainsKey(magnitudeDatum.magnitude))
+                {
+                    data.Y.GainPoints.Add(magnitudeDatum.magnitude, ySlope);
+                }
+
+                lastInputMagnitude = magnitudeDatum.magnitude;
+                lastOutputMagnitudeX = xOut;
+                lastOutputMagnitudeY = yOut;
+            }
+
+            data.Combined.OrderedVelocityPointsList.AddRange(data.Combined.VelocityPoints.Values.ToList());
+        }
+
         public ReadOnlyCollection<MagnitudeData> GetMagnitudes()
         {
             var magnitudes = new List<MagnitudeData>();
@@ -175,6 +238,30 @@ namespace grapher.Models.Calculations
             return Magnitude(x, y) / time;
         }
 
+        public static bool ShouldStripSens(ref DriverSettings settings) =>
+            settings.sensitivity.x != settings.sensitivity.y;
+
+        public static bool ShouldStripRot(ref DriverSettings settings) =>
+            settings.rotation > 0;
+
+        public static (double, double) GetSens(ref DriverSettings settings) =>
+            (settings.sensitivity.x, settings.sensitivity.y);
+
+        public static (double, double) GetRotVector(ref DriverSettings settings) =>
+            (Math.Cos(settings.rotation), Math.Sin(settings.rotation));
+
+        public static (double, double) StripSens(double outputX, double outputY, double sensitivityX, double sensitivityY) =>
+            (outputX / sensitivityX, outputY / sensitivityY);
+
+        public (double, double) StripRot(double outputX, double outputY, double rotX, double rotY) =>
+            (outputX * rotX + outputY * rotY, outputX * rotY - outputY * rotX);
+
+        public (double, double) StripThisSens(double outputX, double outputY) =>
+            StripSens(outputX, outputY, Sensitivity.Item1, Sensitivity.Item2);
+
+        public (double, double) StripThisRot(double outputX, double outputY) =>
+            StripRot(outputX, outputY, RotationVector.Item1, RotationVector.Item2);
+
         public void ScaleByMouseSettings()
         {
             var dpiPollFactor = DPI.Data / PollRate.Data;
diff --git a/grapher/Models/Calculations/AccelChartData.cs b/grapher/Models/Calculations/AccelChartData.cs
index 8c0c8ea..fbf1944 100644
--- a/grapher/Models/Calculations/AccelChartData.cs
+++ b/grapher/Models/Calculations/AccelChartData.cs
@@ -52,12 +52,7 @@ namespace grapher.Models.Calculations
             }
             else
             {
-                var velIdx = OrderedVelocityPointsList.BinarySearch(outVelocityValue);
-
-                if (velIdx < 0)
-                {
-                    velIdx = ~velIdx;
-                }
+                var velIdx = GetVelocityIndex(outVelocityValue);
 
                 velIdx = Math.Min(velIdx, VelocityPoints.Count - 1);
                 values = (VelocityPoints.ElementAt(velIdx).Key, AccelPoints.ElementAt(velIdx).Value, GainPoints.ElementAt(velIdx).Value);
@@ -66,6 +61,30 @@ namespace grapher.Models.Calculations
             }
         }
 
+        public (double, double, double) ValuesAtIndex(int index)
+        {
+            return (AccelPoints.ElementAt(index).Value, VelocityPoints.ElementAt(index).Value, GainPoints.ElementAt(index).Value);
+        }
+
+        public (double, double, double) ValuesAtInVelocity(double inVelocity)
+        {
+            return (AccelPoints[inVelocity], VelocityPoints[inVelocity], GainPoints[inVelocity]);
+        }
+
+        public int GetVelocityIndex(double outVelocityValue)
+        {
+            var velIdx = OrderedVelocityPointsList.BinarySearch(outVelocityValue);
+
+            if (velIdx < 0)
+            {
+                velIdx = ~velIdx;
+            }
+
+            velIdx = Math.Min(velIdx, VelocityPoints.Count - 1);
+
+            return velIdx;
+        }
+
         #endregion Methods
     }
 }
diff --git a/grapher/Models/Calculations/AccelData.cs b/grapher/Models/Calculations/AccelData.cs
index eef4d01..67d4f3f 100644
--- a/grapher/Models/Calculations/AccelData.cs
+++ b/grapher/Models/Calculations/AccelData.cs
@@ -1,5 +1,8 @@
 using grapher.Models.Charts;
+using grapher.Models.Serialized;
 using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace grapher.Models.Calculations
 {
@@ -19,6 +22,8 @@ namespace grapher.Models.Calculations
             Estimated = combined;
             EstimatedX = x;
             EstimatedY = y;
+
+            OutVelocityToPoints = new Dictionary<double, (double, double, double, double, double, double, double)>();
         }
 
         #endregion Constructors
@@ -37,6 +42,8 @@ namespace grapher.Models.Calculations
 
         private EstimatedPoints EstimatedY { get; }
 
+        private Dictionary<double, (double, double, double, double, double, double, double)> OutVelocityToPoints { get; }
+
         #endregion Properties
 
         #region Methods
@@ -46,22 +53,23 @@ namespace grapher.Models.Calculations
             Combined.Clear();
             X.Clear();
             Y.Clear();
+            OutVelocityToPoints.Clear();
         }
 
         public void CalculateDots(int x, int y, double timeInMs)
         {
-            var magnitude = AccelCalculator.Velocity(x, y, timeInMs);
+            var outVelocity = AccelCalculator.Velocity(x, y, timeInMs);
 
-            (var inCombVel, var combSens, var combGain) = Combined.FindPointValuesFromOut(magnitude);
-            Estimated.Velocity.Set(inCombVel, magnitude);
+            (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(int x, int y, double timeInMs)
         {
-            var outX = Math.Abs(x);
-            var outY = Math.Abs(y);
+            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);
@@ -74,6 +82,36 @@ namespace grapher.Models.Calculations
             EstimatedY.Gain.Set(inYVelocity, yGain);
         }
 
+        public void CalculateDotsCombinedDiffSens(int x, int 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
     }
 }