Mock.PolarParser. Fixed a bug where it would only parse the first half of each row.

Mock.Polars. addEstimate also builds up a unique list of angles from the data file, instead of dynamically generating that when calculating a VMG.
addEstimate also adds estimates with negative angles (e.g., 45deg+windSpeed+boatSpeed, and -45deg+windSpeed+boatSpeed).
calculateVMG now accepts an upper and lower bounds to the allowed VMG bearing it returns - this way you can get VMGs only within a certain angle interval (e.g., [16, 99] degrees).
Also fixed some bugs in calculateVMG where it wasn't actually using the angles and such correctly.
Improved the test case slightly, but still need to calculate correct values by hand.

#story[873]

mock/src/main/java/seng302/DataInput/PolarParser.java

@@ -81,8 +81,7 @@ public class PolarParser {
 
             //For each pair of columns (the pair is angle, speed).
             //We start at column 1 since column 0 is the wind speed column.
-            // (row.length - 1) / 2    means the number of pairs of angle+speed.
+            for (int i = 1; i < row.length; i += 2) {
-            for (int i = 1; i < (row.length - 1) / 2; i += 2) {
 
                 //Add angle+speed=velocity estimate to polar table.
                 try {

mock/src/main/java/seng302/Model/Polars.java

@@ -17,6 +17,9 @@ public class Polars {
     ///Internal store of data. Maps pair<windSpeed, windAngle> to boatSpeed.
     private HashMap<Pair<Double, Double>, Double> polarValues = new HashMap<>();
 
+    ///Stores a list of angles from the polar table - this is used during the calculateVMG function.
+    private ArrayList<Double> polarAngles = new ArrayList<>();
+
     /**
      * Ctor.
      */
@@ -26,26 +29,56 @@ public class Polars {
 
     /**
      * Adds an estimated velocity to the polar table object, for a given (windSpeed, windAngle) pair. That is, stores a mapping from (windSpeed, windAngle) to (boatVelocity).
+     * Note: an estimate means given a specific wind speed of trueWindSpeed, if the boat travels relativeWindAngle degrees towards the wind, it will move at boatSpeed knots. E.g., trueWindSpeed = 20kn, relativeWindAngle = 45 degrees, boatSpeed = 25kn. If the boat travels towards the wind, plus or minus 45 degrees either side, it will move at 25kn.
      * @param trueWindSpeed The true wind speed of the estimate.
-     * @param trueWindAngle The true wind angle of the estimate.
+     * @param relativeWindAngle The relative wind angle between the wind direction + 180 degrees and the boat's direction of the estimate.
      * @param boatSpeed The boat speed of the estimate.
      */
-    public void addEstimate(double trueWindSpeed, double trueWindAngle, double boatSpeed){
+    public void addEstimate(double trueWindSpeed, double relativeWindAngle, double boatSpeed){
-        Pair newKey = new Pair(trueWindSpeed, trueWindAngle);
+
-        polarValues.put(newKey, boatSpeed);
+        //We also add the same values with a negative angle, as the data file contains data for 0-180 degrees, but we also need 180-360 degrees. This is because it may turn out that going 5 degrees into the wind gives us, say, 9knots, but -5 into the wind may give us 10knots, towards our destination.
+
+        //Add estimate to map.
+        Pair newKeyPositive = new Pair(trueWindSpeed, relativeWindAngle);
+        polarValues.put(newKeyPositive, boatSpeed);
+
+        double negativeAngle = -relativeWindAngle;
+        Pair newKeyNegative = new Pair(trueWindSpeed, negativeAngle);
+        polarValues.put(newKeyNegative, boatSpeed);
+
+
+        //Add angle to angle list.
+        if (!this.polarAngles.contains(relativeWindAngle)) {
+            this.polarAngles.add(relativeWindAngle);
+        }
+
+        if (!this.polarAngles.contains(negativeAngle)) {
+            this.polarAngles.add(negativeAngle);
+        }
+
+
+        //System.out.println("adding wind speed: " + trueWindSpeed + ", wind angle: " + relativeWindAngle + ", boat speed: " + boatSpeed);//TEMP DEBUG REMOVE
+        //System.out.println("adding wind speed: " + trueWindSpeed + ", wind angle: " + negativeAngle + ", boat speed: " + boatSpeed);//TEMP DEBUG REMOVE
+
+
+
     }
 
 
     /**
-     * Calculates the VMG for a given wind angle, wind speed, and angle to destination.
+     * Calculates the VMG for a given wind angle, wind speed, and angle to destination. Will only return VMGs that have a true bearing (angle) within a given bound - this is to ensure that you can calculate VMGs without going out of bounds. If you don't care about bearing bounds, simple pass in lower = 0, upper = 360.
      * @param trueWindAngle The current true wind angle.
      * @param trueWindSpeed The current true wind speed.
      * @param destinationAngle The angle between the boat and the destination point.
+     * @param bearingLowerBound The lowest bearing (angle) that the boat may travel on.
+     * @param bearingUpperBound The highest bearing (angle) that the boat may travel on.
      * @return
      */
-    public VMG calculateVMG(double trueWindAngle, double trueWindSpeed, double destinationAngle) {
+    public VMG calculateVMG(double trueWindAngle, double trueWindSpeed, double destinationAngle, double bearingLowerBound, double bearingUpperBound) {
 
         //Currently a fairly simple implementation where we find the wind speed that is less than or equal to the current wind speed (the lower bound), and then find the specific angle (with no interpolation) that gives the best VMG.
+        //TODO we need to add interpolation between angles for a given wind speed (e.g., we have 0 deg, 30 deg, but the optimal bearing may be 17.3 degrees).
+        //TODO we should also interpolate between wind speeds (e.g., we have 12kn and 16kn, but if the wind speed is actually 15.999kn, then we should interpolate to get a more accurate final value).
 
         double polarWindSpeed = 0;
 
@@ -60,41 +93,65 @@ public class Polars {
             }
         }
 
-        //We create a list of wind angles because we need (speed, angle) pairs to look into the map.
-        ArrayList<Double> windAngles = new ArrayList<>();
-        for (Pair<Double, Double> key : this.polarValues.keySet()) {
-
-            //Don't add angles multiple times.
-            double angle = key.getValue();
-            if (!windAngles.contains(angle)) {
-                windAngles.add(angle);
-            }
-        }
 
         //Find the angle with the best VMG.
-        //TODO need to differentiate between windward and leeward.
         double bestVMGAngle = 0;
         double bestVMGVelocity = 0;
-        for (double tackAngle : windAngles) {
+        for (double polarAngle : this.polarAngles) {
-            Pair<Double,Double> key = new Pair<Double,Double>(polarWindSpeed, tackAngle);
+
+            Pair<Double,Double> key = new Pair<>(polarWindSpeed, polarAngle);
+
+            //System.out.println("selecting " + polarAngle + " degrees from wind dir, and " + polarWindSpeed + "knots wind speed.");//TEMP DEBUG REMOVE
+
+            //We need to check that the map contains this (speed, angle) pair because some of the datafile entries have different angles in the same column (e.g., (16kn, 45 deg) and (20kn, 43 deg), but there is no (20kn, 45 deg).
             if (this.polarValues.containsKey(key)) {
+
                 //This is the velocity from the polar table at this wind speed/angle.
                 double estVelocity = this.polarValues.get(key);
-                double angleBetweenDestAndTack = tackAngle - destinationAngle;
+
+
+                //System.out.println("speed is est. " + estVelocity + "knots.");//TEMP DEBUG REMOVE
+
+                //This is the true bearing of the boat, if it went at the angle against the wind.
+                //For polarAngle > 90, it means that the boat is actually going _with_ the wind (gybe).
+                double trueBoatBearing = trueWindAngle + polarAngle + 180d;
+                while (trueBoatBearing >= 360) {
+                    trueBoatBearing -= 360;
+                }
+
+                //System.out.println("true boat bearing is " + trueBoatBearing + " degrees.");//TEMP DEBUG REMOVE
+
+                //Check that the trueBoatBearing is actually within the accepted interval.
+                if ((trueBoatBearing <= bearingLowerBound) || (trueBoatBearing >= bearingUpperBound)) {
+                    //If the angle is too small or too great, don't use it - skip to the next iteration.
+                    continue;
+                }
+                else {
+                    //If it is acceptable...
+
+                    //System.out.println("this is in the acceptable range");//TEMP DEBUG REMOVE
+
+                    //This is the delta angle between the boat's true bearing and the destination.
+                    double angleBetweenDestAndTack = trueBoatBearing - destinationAngle;
                     //This is the estimated velocity towards the target (e.g., angling away from the target reduces velocity).
-                double vmgTemp = Math.cos(angleBetweenDestAndTack) * estVelocity;
+                    double vmgTemp = Math.cos(Math.toRadians(angleBetweenDestAndTack)) * estVelocity;
+
+                    //System.out.println("angle between destination and boat bearing is " + angleBetweenDestAndTack + " degrees.");//TEMP DEBUG REMOVE
+                    //System.out.println("this has an overall velocity of " + vmgTemp + "knots.");//TEMP DEBUG REMOVE
 
                     //Check that the velocity is better.
                     if (vmgTemp > bestVMGVelocity) {
+                        //System.out.println("This is the new best velocity. Previous was " + bestVMGVelocity + "knots at " + bestVMGAngle + " degrees.");//TEMP DEBUG REMOVE
                         bestVMGVelocity = vmgTemp;
-                    bestVMGAngle = tackAngle;
+                        bestVMGAngle = trueBoatBearing;
                     }
 
                 }
+            }
 
         }
 
-        System.out.println("VMG speed = " + bestVMGVelocity + " , VMG angle = " + bestVMGAngle);//TEMP DEBUG REMOVE
+        //System.out.println("VMG speed = " + bestVMGVelocity + " , VMG angle = " + bestVMGAngle);//TEMP DEBUG REMOVE
 
         //Create the VMG object and return it.
         return new VMG(bestVMGVelocity, bestVMGAngle);

mock/src/test/java/seng302/Model/PolarsTest.java

@@ -11,6 +11,7 @@ import static org.testng.Assert.*;
  */
 public class PolarsTest {
 
+
     @Test
     /**
      * Tests if we can parse a polar data file (stored in a string), create a polar table, and calculate VMG for a variety of values.
@@ -18,7 +19,7 @@ public class PolarsTest {
     public void testParseAndVMG() throws Exception {
 
         //Read data.
-        Polars polars;
+        Polars polars = null;
         try {
             //Parse data file.
             polars = PolarParser.parse("polars/acc_polars.csv");
@@ -27,20 +28,45 @@ public class PolarsTest {
             assertTrue(false);
         }
 
+
+
+        double angleEpsilon = 2;
+        double speedEpsilon = 2;//Are these epsilons a bit too big?
+
         //Test 1.
-        //TODO make these tests actually do something when the calculateVMG function is added.
         double windAngle1 = 31.5;
         double destAngle1 = 65.32;
         double windSpeed1 = 15;//knots
-        //double vmgAngle1 = TODO;
+        double vmgAngle1 = 88;
-        //double vmgSpeed1 = TODO;
+        double vmgSpeed1 = 12;
+
+        VMG calcVMG1 = polars.calculateVMG(windAngle1, windSpeed1, destAngle1, 0, 360);
+        double calcVMGAngle1 = calcVMG1.getBearing();
+        double calcVMGSpeed1 = calcVMG1.getSpeed();
+
+        System.out.println("VMG speed = " + calcVMGSpeed1 + " , VMG angle = " + calcVMGAngle1);//TEMP DEBUG REMOVE
+
+
+        //assertEquals(calcVMGAngle1, vmgAngle1, angleEpsilon);
+        //assertEquals(calcVMGSpeed1, vmgSpeed1, speedEpsilon);
+
+
+        //Test 2.
+        double windAngle2 = 200;
+        double destAngle2 = 35;
+        double windSpeed2 = 20;//knots
+        double vmgAngle2 = 88;
+        double vmgSpeed2 = 12;
+
+        VMG calcVMG2 = polars.calculateVMG(windAngle2, windSpeed2, destAngle2, 0, 360);
+        double calcVMGAngle2 = calcVMG2.getBearing();
+        double calcVMGSpeed2 = calcVMG2.getSpeed();
+
+        System.out.println("VMG speed = " + calcVMGSpeed2 + " , VMG angle = " + calcVMGAngle2);//TEMP DEBUG REMOVE
 
-        //VMG calcVMG1 = Polars.calculateVMG(windAngle1, destAngle1, windSpeed1);
-        //double calcVMGAngle1 = calcVMG1.getKey();
-        //double calcVMGSpeed1 = calcVMG1.getValue();
 
-        //assertEquals(vmgAngle1, calcVMGAngle1, 0.1);
+        //assertEquals(calcVMGAngle2, vmgAngle2, angleEpsilon);
-        //assertEquals(vmgSpeed1, calcVMGSpeed1, 0.1);
+        //assertEquals(calcVMGSpeed2, vmgSpeed2, speedEpsilon);
 
     }