diff --git a/mock/src/main/java/seng302/Model/Polars.java b/mock/src/main/java/seng302/Model/Polars.java index f6844d0e..81242f07 100644 --- a/mock/src/main/java/seng302/Model/Polars.java +++ b/mock/src/main/java/seng302/Model/Polars.java @@ -18,7 +18,11 @@ public class Polars { private HashMap, Double> polarValues = new HashMap<>(); ///Stores a list of angles from the polar table - this is used during the calculateVMG function. - private ArrayList polarAngles = new ArrayList<>(); + ///Maps between windSpeed and a list of angles for that wind speed. + private HashMap> polarAngles = new HashMap<>(); + + + /** * Ctor. @@ -38,33 +42,42 @@ public class Polars { //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. + //Create the array to store angles for this wind speed if it doesn't exist. + if (!this.polarAngles.containsKey(trueWindSpeed)) { + this.polarAngles.put(trueWindSpeed, new ArrayList<>()); + } + //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); + double negativeAngle = 360d - relativeWindAngle; + //This essentially does angle modulo 360, to get something in the interval [0, 360). + while (negativeAngle >= 360d) { + negativeAngle -= 360d; + } + //Ensure that the positive and negative angles aren't the same (e.g., pos = 0, neg = 360 - 0 = 0. + if (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.get(trueWindSpeed).contains(relativeWindAngle)) { + this.polarAngles.get(trueWindSpeed).add(relativeWindAngle); } - if (!this.polarAngles.contains(negativeAngle)) { - this.polarAngles.add(negativeAngle); + if (!this.polarAngles.get(trueWindSpeed).contains(negativeAngle)) { + this.polarAngles.get(trueWindSpeed).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. 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. @@ -80,7 +93,13 @@ public class Polars { //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; + //Sorts polar angles. + for (ArrayList angles : this.polarAngles.values()) { + angles.sort(null); + } + + //-1 indicates that we haven't found any smaller wind speeds in our map. + double polarWindSpeed = -1; //Find the lower bound wind speed from the polar table. for (Pair key : this.polarValues.keySet()) { @@ -93,70 +112,109 @@ public class Polars { } } + //If we never found a smaller speed value (e.g., smallest speed in table is 4kn, user provided 2kn), then for now we give a vector with 0 speed towards destination. Later, this should interpolate between adjacent wind speeds. + if (polarWindSpeed == -1) { + return new VMG(0, destinationAngle); + } + + //Find the angle with the best VMG. + double bestVMGAngle = 0; double bestVMGVelocity = 0; - for (double polarAngle : this.polarAngles) { + //The list of polar angles for this wind speed. + ArrayList polarAngles = this.polarAngles.get(polarWindSpeed); - Pair key = new Pair<>(polarWindSpeed, polarAngle); + //For all angles in the accepted interval (in 1 degree increments). + for (double angle = 0; angle < 360; angle += 1) { - //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 true bearing of the boat, if it went at the angle against the wind. + //For angle > 90 and angle < 270, it means that the boat is actually going _with_ the wind (gybe). + double trueBoatBearing = trueWindAngle + angle + 180d; + while (trueBoatBearing >= 360) { + trueBoatBearing -= 360; + } - //This is the velocity from the polar table at this wind speed/angle. - double estVelocity = this.polarValues.get(key); + //Check that the boat's bearing would actually be acceptable. + if ((trueBoatBearing <= bearingLowerBound) || (trueBoatBearing > bearingUpperBound)) { + //If the angle is too small or too great, don't use it - skip to the next iteration. + continue; + } - //System.out.println("speed is est. " + estVelocity + "knots.");//TEMP DEBUG REMOVE + //Basic linear interpolation. Find the nearest two angles from the table, and interpolate between them. - //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; + //Check which pair of adjacent points the angle is between. + boolean foundInterval = false; + double lowerBound = 0; + double upperBound = 0; + for (int i = 0; i < polarAngles.size() - 1; i++) { + if ((angle >= polarAngles.get(i)) && (angle < polarAngles.get(i + 1))) { + foundInterval = true; + lowerBound = polarAngles.get(i); + upperBound = polarAngles.get(i + 1); + break; } + } + + //Calculate how far between those points the angle is. + if (!foundInterval) { + //If we never found the interval, then it must be the "last" interval, between the i'th and 0'th values. + lowerBound = polarAngles.get(polarAngles.size() - 1); + upperBound = polarAngles.get(0); + } - //System.out.println("true boat bearing is " + trueBoatBearing + " degrees.");//TEMP DEBUG REMOVE + //This is the "distance" between the angle and its lower bound. + //I.e., L----A-----------U + // <----> is lowerDelta. + double lowerDelta = angle - lowerBound; + + //This is the "distance" between the upper and lower bound. + //I.e., L----A-----------U + // <----------------> is intervalDelta. + //This can potentially be negative if we have, e.g., lower = 340deg, upper = 0deg, delta = -340deg. + double intervalDelta = upperBound - lowerBound; + //If it _is_ negative, modulo it to make it positive. + //E.g., -340deg = +20deg. + if (intervalDelta < 0) { + intervalDelta += 360d; + } - //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... + //This is how far between the lower and upper bounds the angle is, as a proportion (e.g., 0.5 = half-way, 0.9 = close to upper). + double interpolationScalar = lowerDelta / intervalDelta; - //System.out.println("this is in the acceptable range");//TEMP DEBUG REMOVE + //Get the estimated boat speeds for the lower and upper angles. + Pair lowerKey = new Pair<>(polarWindSpeed, lowerBound); + Pair upperKey = new Pair<>(polarWindSpeed, upperBound); + double lowerSpeed = this.polarValues.get(lowerKey); + double upperSpeed = this.polarValues.get(upperKey); + //Get the delta between upper and lower speeds. + double speedDelta = upperSpeed - lowerSpeed; - //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(Math.toRadians(angleBetweenDestAndTack)) * estVelocity; + //Calculate the speed at the interpolated angle. + double interpolatedSpeed = lowerSpeed + (speedDelta * interpolationScalar); - //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 = trueBoatBearing; - } - } + //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(Math.toRadians(angleBetweenDestAndTack)) * interpolatedSpeed; + + + //Check that the velocity is better. + if (vmgTemp > bestVMGVelocity) { + bestVMGVelocity = vmgTemp; + bestVMGAngle = trueBoatBearing; } } - //System.out.println("VMG speed = " + bestVMGVelocity + " , VMG angle = " + bestVMGAngle);//TEMP DEBUG REMOVE //Create the VMG object and return it. return new VMG(bestVMGVelocity, bestVMGAngle); - } diff --git a/mock/src/test/java/seng302/Model/PolarsTest.java b/mock/src/test/java/seng302/Model/PolarsTest.java index c28e78f1..59680fab 100644 --- a/mock/src/test/java/seng302/Model/PolarsTest.java +++ b/mock/src/test/java/seng302/Model/PolarsTest.java @@ -34,10 +34,11 @@ public class PolarsTest { double speedEpsilon = 2;//Are these epsilons a bit too big? //Test 1. + //This test has a wind speed that is between two values from the table (12kn, 16kn, this is 15.9kn). double windAngle1 = 31.5; double destAngle1 = 65.32; - double windSpeed1 = 15;//knots - double vmgAngle1 = 88; + double windSpeed1 = 15.9;//knots + double vmgAngle1 = 88; //TODO the expected results need to be calculated and placed here. double vmgSpeed1 = 12; VMG calcVMG1 = polars.calculateVMG(windAngle1, windSpeed1, destAngle1, 0, 360); @@ -52,9 +53,10 @@ public class PolarsTest { //Test 2. + //This test has a wind speed much larger than any in the table (max from table is 30kn, this is 40kn). double windAngle2 = 200; double destAngle2 = 35; - double windSpeed2 = 20;//knots + double windSpeed2 = 40;//knots double vmgAngle2 = 88; double vmgSpeed2 = 12; @@ -68,6 +70,25 @@ public class PolarsTest { //assertEquals(calcVMGAngle2, vmgAngle2, angleEpsilon); //assertEquals(calcVMGSpeed2, vmgSpeed2, speedEpsilon); + + //Test 3. + //This test has a wind speed lower than any non-zero values from the table (table has 0kn, 4kn, this is 2kn). + double windAngle3 = 345; + double destAngle3 = 199; + double windSpeed3 = 2;//knots + double vmgAngle3 = 88; + double vmgSpeed3 = 12; + + VMG calcVMG3 = polars.calculateVMG(windAngle3, windSpeed3, destAngle3, 0, 360); + double calcVMGAngle3 = calcVMG3.getBearing(); + double calcVMGSpeed3 = calcVMG3.getSpeed(); + + System.out.println("VMG speed = " + calcVMGSpeed3 + " , VMG angle = " + calcVMGAngle3);//TEMP DEBUG REMOVE + + + //assertEquals(calcVMGAngle3, vmgAngle3, angleEpsilon); + //assertEquals(calcVMGSpeed3, vmgSpeed3, speedEpsilon); + } }