Update to v0.4.2 API and switch coding style

Author: X9VoiD

HawkuFilters/NoiseReduction.cs

@@ -9,26 +9,26 @@ namespace OpenTabletDriver.Plugin
     [PluginName("TabletDriver Noise Reduction")]
     public class TabletDriverNoiseReduction : IFilter
     {
-        private LinkedList<Vector2> _buffer = new LinkedList<Vector2>();
-        private float _distThreshold, _distMax;
-        private const int _iterations = 10;
-        private int _samples = 10;
-        private Vector2 _lastPoint;
+        private readonly LinkedList<Vector2> buffer = new LinkedList<Vector2>();
+        private float distThreshold, distMax;
+        private const int iterations = 10;
+        private int samples = 10;
+        private Vector2 lastPoint;
 
         public Vector2 Filter(Vector2 point)
         {
             SetTarget(point);
 
-            if (_buffer.Count <= 1)
+            if (this.buffer.Count <= 1)
             {
                 return SetOutput(point);
             }
 
             // Calculate geometric median from the buffer positions
-            GetGeometricMedianVector(ref _lastPoint);
+            this.lastPoint = GetGeometricMedianVector(this.lastPoint);
 
             // Distance between latest position and ring buffer
-            var distance = Vector2.Distance(point, _lastPoint);
+            var distance = Vector2.Distance(point, this.lastPoint);
 
             // Distance larger than threshold -> modify the ring buffer
             if (distance > DistThreshold)
@@ -39,23 +39,23 @@ public Vector2 Filter(Vector2 point)
                 // Distance ratio should be between 0.0 and 1.0
                 // 0.0 -> distance == distanceThreshold
                 // 1.0 -> distance == distanceMaximum
-                distanceRatio = (distance - DistThreshold) / (_distMax - DistThreshold);
+                distanceRatio = (distance - DistThreshold) / (this.distMax - DistThreshold);
 
                 if (distanceRatio >= 1f)
                 {
                     // Distance larger than maximum -> fill buffer with the latest target position
-                    var bufCount = _buffer.Count;
-                    _buffer.Clear();
+                    var bufCount = this.buffer.Count;
+                    this.buffer.Clear();
                     for (int i = 0; i < bufCount; i++)
-                        _buffer.AddLast(point);
+                        this.buffer.AddLast(point);
                     return SetOutput(point);
                 }
                 else
                 {
                     // Move buffer positions and current position towards the latest target using linear interpolation
                     // Amount of movement is the distance ratio between threshold and maximum
 
-                    var bufNode = _buffer.First;
+                    var bufNode = buffer.First;
 
                     while (bufNode != null)
                     {
@@ -66,29 +66,29 @@ public Vector2 Filter(Vector2 point)
                         bufNode = bufNode.Next;
                     }
 
-                    _lastPoint.X += (float)((point.X - _lastPoint.X) * distanceRatio);
-                    _lastPoint.Y += (float)((point.Y - _lastPoint.Y) * distanceRatio);
+                    this.lastPoint.X += (float)((point.X - this.lastPoint.X) * distanceRatio);
+                    this.lastPoint.Y += (float)((point.Y - this.lastPoint.Y) * distanceRatio);
 
-                    return _lastPoint;
+                    return this.lastPoint;
                 }
             }
             return SetOutput(point);
         }
 
         private void SetTarget(Vector2 point)
         {
-            _buffer.AddLast(point);
-            while (_buffer.Count > Samples)
-                _buffer.RemoveFirst();
+            buffer.AddLast(point);
+            while (buffer.Count > Samples)
+                buffer.RemoveFirst();
         }
 
         private Vector2 SetOutput(Vector2 point)
         {
-            _lastPoint = point;
+            this.lastPoint = point;
             return point;
         }
 
-        private Vector2 GetGeometricMedianVector(ref Vector2 point)
+        private Vector2 GetGeometricMedianVector(Vector2 point)
         {
             var candidate = new Vector2();
             var next = new Vector2();
@@ -98,15 +98,15 @@ private Vector2 GetGeometricMedianVector(ref Vector2 point)
 
             // Calculate the starting position
             if (!GetAverageVector(ref candidate))
-                return _lastPoint;
+                return this.lastPoint;
 
             // Iterate
-            for (int iteration = 0; iteration < _iterations; iteration++)
+            for (int iteration = 0; iteration < iterations; iteration++)
             {
                 denominator = 0;
 
                 // Loop through the buffer and calculate a denominator.
-                foreach (var bufferPoint in _buffer)
+                foreach (var bufferPoint in buffer)
                 {
                     distance = Vector2.Distance(candidate, bufferPoint);
 
@@ -121,7 +121,7 @@ private Vector2 GetGeometricMedianVector(ref Vector2 point)
                 next.Y = 0;
 
                 // Loop through the buffer and calculate a weighted average
-                foreach (var bufferPoint in _buffer)
+                foreach (var bufferPoint in buffer)
                 {
                     distance = Vector2.Distance(candidate, bufferPoint);
 
@@ -147,20 +147,20 @@ private Vector2 GetGeometricMedianVector(ref Vector2 point)
 
         private bool GetAverageVector(ref Vector2 point)
         {
-            if (_buffer.Count == 0)
+            if (buffer.Count == 0)
                 return false;
 
             point.X = 0;
             point.Y = 0;
 
-            foreach (var bufferPoint in _buffer)
+            foreach (var bufferPoint in buffer)
             {
                 point.X += bufferPoint.X;
                 point.Y += bufferPoint.Y;
             }
 
-            point.X /= _buffer.Count;
-            point.Y /= _buffer.Count;
+            point.X /= buffer.Count;
+            point.Y /= buffer.Count;
             return true;
         }
 
@@ -169,20 +169,20 @@ public int Samples
         { 
             set
             {
-                _samples = Math.Clamp(value, 0, 20);
+                this.samples = Math.Clamp(value, 0, 20);
             }
-            get => _samples;
+            get => this.samples;
         }
 
-        [UnitProperty("Distance Threshold", "px")]
+        [Property("Distance Threshold"), Unit("px")]
         public float DistThreshold
         {
             set
             {
-                _distThreshold = Math.Clamp(value, 0, 10);
-                _distMax = value * 2;
+                this.distThreshold = Math.Clamp(value, 0, 10);
+                distMax = value * 2;
             }
-            get => _distThreshold;
+            get => this.distThreshold;
         }
 
         public FilterStage FilterStage => FilterStage.PostTranspose;