Added faulty movement checking function

code/src/Fitbot/app/src/main/java/com/example/fitbot/util/processing/InputProcessor.java

@@ -112,6 +112,7 @@ public class InputProcessor {
         ExerciseManager.TOTAL_REPETITIONS_REQUIRED += ExerciseManager.DEFAULT_EXERCISE_REPETITIONS;
         ExerciseManager.TOTAL_EXERCISES_PREFORMED++;
 
+        this.selfRotationVectorPaths = new ArrayList[2];
         this.selfRotationVectorPaths[0] = new ArrayList<>();
         this.selfRotationVectorPaths[1] = new ArrayList<>();
 
@@ -130,14 +131,14 @@ public class InputProcessor {
      */
     public void onAdequateRepetition() {
         ExerciseManager.TOTAL_REPETITIONS_PERFORMED++;
-        new FitnessActivity().incrementProgress();
+        this.parentActivity.incrementProgress();
     }
 
     /**
      * Method that is called whenever the user performs a bad repetition.
      */
     public void onInadequateRepetition() {
-        new FitnessActivity().triggerColorBurst(false);
+        this.parentActivity.triggerColorBurst(false);
     }
 
     /**
@@ -352,55 +353,33 @@ public class InputProcessor {
      }*/
 
     /**
-     * Function for getting the error offsets of the user's path compared to the
-     * target path at a given point in time.
      *
-     * @param sensorId The sensor ID to get the error offsets from.
-     * @param time     The time to get the error offsets from.
-     *                 This value must be >= 0 && <= exerciseTime, otherwise
-     *                 the error will be 0 by default.
-     * @return A list of error offsets of the motion data compared to the reference path.
      */
-    public double getError(int sensorId, float time) {
+    public boolean isFaultyMovement(int sensorId, float time) {
 
         // Ensure the sensor ID is within the bounds of the array
         if (sensorId < 0 || sensorId >= selfRotationVectorPaths.length)
-            return 0.0d;
+            return false;
 
-        // Calculate the index of the rotational vector where we're currently at
+        // Calculate the index of the reference rotation vector
-        int targetRotationIdx =
+        // This is done by calculating the closest index of the last received vector
+        // to the current time.
+        // i = | (t % T) / T * N |
 
-        /*
+        int i, referenceIndex;
 
-        // Index of the current rotation vector
+        for ( i = 0; i < selfRotationVectorPaths.length; i++)
-        int targetIndex = (int) ((this.exerciseDurationInSeconds / this.targetRotationVectorPaths[sensorId].length) * time);
+        {
-        int selfIndex = (int) (this.selfRotationVectorPaths[sensorId].length / this.sampleRate * time);
+            referenceIndex = (int) (Math.round(
-
+                    ((time % this.exerciseRepetitionDurationInSeconds) /
-        // Ensure the indexes are within the bounds of the array
+                            (this.exerciseRepetitionDurationInSeconds)) * this.targetRotationVectorPaths[i].length))
-        if (
+                    % this.targetRotationVectorPaths[i].length;
-                targetIndex >= 0 && targetIndex <= this.targetRotationVectorPaths[sensorId].length - 1 &&
+            // If distance is greater than the threshold, return true
-                selfIndex >= 0 && selfIndex <= this.selfRotationVectorPaths[sensorId].length - 1 &&
+            if (this.selfRotationVectorPaths[i].get(this.selfRotationVectorPaths[i].size() - 1).distance(
-                this.selfRotationVectorPaths[sensorId][selfIndex] != null &&
+                    this.targetRotationVectorPaths[i][referenceIndex]) > ExerciseManager.EXERCISE_ERROR_MARGIN)
-                this.targetRotationVectorPaths[sensorId][targetIndex] != null
+                return true;
-        ) {
-            return this.selfRotationVectorPaths[sensorId][selfIndex].distance(this.targetRotationVectorPaths[sensorId][targetIndex]);
-        }*/
-        return 0.0d;
-    }
-
-    /**
-     * Method for getting the average error of the motion data
-     * compared to the reference path.
-     *
-     * @param sensorId The sensor ID to get the error offsets from.
-     * @return The average error of the motion data compared to the reference path.
-     */
-    public double getAverageError(int sensorId) {
-        double error = 0;
-        for (int i = 0; i < this.exerciseRepetitionDurationInSeconds; i++) {
-            error += getError(sensorId, i);
         }
-        return error / this.exerciseRepetitionDurationInSeconds;
+        return false;
     }
 
     public float secondsPassed() {