Removed the old mock/network/visualiser files.
This commit is contained in:
fjc40
@@ -1,75 +0,0 @@
|
||||
package seng302;
|
||||
|
||||
|
||||
import javafx.application.Application;
|
||||
import javafx.stage.Stage;
|
||||
import org.w3c.dom.Document;
|
||||
import org.xml.sax.InputSource;
|
||||
import org.xml.sax.SAXException;
|
||||
import seng302.DataInput.PolarParser;
|
||||
import seng302.DataInput.XMLReader;
|
||||
import seng302.Model.Event;
|
||||
import seng302.Model.Polars;
|
||||
|
||||
import javax.xml.parsers.DocumentBuilder;
|
||||
import javax.xml.parsers.DocumentBuilderFactory;
|
||||
import javax.xml.parsers.ParserConfigurationException;
|
||||
import javax.xml.transform.TransformerException;
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.Charset;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
|
||||
public class App extends Application {
|
||||
|
||||
/**
|
||||
* Entry point for running the programme
|
||||
*
|
||||
* @param args for starting the programme
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
launch(args);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void start(Stage primaryStage) {
|
||||
try {
|
||||
Polars boatPolars = PolarParser.parse("polars/acc_polars.csv");
|
||||
|
||||
String regattaXML = readFile("mockXML/regattaTest.xml", StandardCharsets.UTF_8);
|
||||
String raceXML = readFile("mockXML/raceTest.xml", StandardCharsets.UTF_8);
|
||||
String boatXML = readFile("mockXML/boatTest.xml", StandardCharsets.UTF_8);
|
||||
|
||||
Event raceEvent = new Event(raceXML, regattaXML, boatXML, boatPolars);
|
||||
raceEvent.start();
|
||||
|
||||
} catch (Exception e) {
|
||||
//Catch all exceptions, print, and exit.
|
||||
e.printStackTrace();
|
||||
System.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads the Initial Race XML files that are necessary to run the mock.
|
||||
* @param path path of the XML
|
||||
* @param encoding encoding of the xml
|
||||
* @return
|
||||
* @throws IOException No file etc
|
||||
* @throws ParserConfigurationException Issue with the XML formatting
|
||||
* @throws SAXException Issue with XML formatting
|
||||
* @throws TransformerException Issue with the XML format
|
||||
*/
|
||||
private String readFile(String path, Charset encoding) throws IOException, ParserConfigurationException, SAXException, TransformerException {
|
||||
|
||||
InputSource fXmlFile = new InputSource(getClass().getClassLoader().getResourceAsStream(path));
|
||||
|
||||
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
|
||||
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
|
||||
Document doc = dBuilder.parse(fXmlFile);
|
||||
doc.getDocumentElement().normalize();
|
||||
|
||||
return XMLReader.getContents(doc);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
package seng302;
|
||||
|
||||
/**
|
||||
* Constants that are used throughout the program
|
||||
* Created by Erika on 19-Mar-17.
|
||||
*/
|
||||
public class Constants {
|
||||
|
||||
/**
|
||||
* Multiply by this factor to convert nautical miles to meters.
|
||||
* <br>
|
||||
* Divide by this factor to convert meters to nautical miles.
|
||||
* <br>
|
||||
* 1 nautical mile = 1852 meters.
|
||||
*/
|
||||
public static final int NMToMetersConversion = 1852;
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Multiply by this factor to convert Knots to millimeters per second.
|
||||
* <br>
|
||||
* Divide by this factor to convert millimeters per second to Knots.
|
||||
* <br>
|
||||
* 1 knot = 514.444 millimeters per second.
|
||||
*/
|
||||
public static final double KnotsToMMPerSecond = 514.444;
|
||||
|
||||
|
||||
/**
|
||||
* The race pre-start time, in milliseconds. 3 minutes.
|
||||
*/
|
||||
public static final long RacePreStartTime = 3 * 60 * 1000;
|
||||
|
||||
|
||||
/**
|
||||
* The race preparatory time, in milliseconds. 1 minutes.
|
||||
*/
|
||||
public static final long RacePreparatoryTime = 1 * 60 * 1000;
|
||||
|
||||
|
||||
/**
|
||||
* The number of milliseconds in one hour.
|
||||
*/
|
||||
public static long OneHourMilliseconds = 1 * 60 * 60 * 1000;
|
||||
|
||||
|
||||
|
||||
}
|
||||
@@ -1,14 +0,0 @@
|
||||
package seng302.DataInput;
|
||||
|
||||
import seng302.Model.Boat;
|
||||
import seng302.Model.Mark;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Boats Data
|
||||
*/
|
||||
public interface BoatDataSource {
|
||||
Map<Integer, Boat> getBoats();
|
||||
Map<Integer, Mark> getMarkerBoats();
|
||||
}
|
||||
@@ -1,149 +0,0 @@
|
||||
package seng302.DataInput;
|
||||
|
||||
import org.w3c.dom.Element;
|
||||
import org.w3c.dom.Node;
|
||||
import org.xml.sax.SAXException;
|
||||
import seng302.Model.Boat;
|
||||
import seng302.Model.GPSCoordinate;
|
||||
import seng302.Model.Mark;
|
||||
import seng302.Model.Polars;
|
||||
|
||||
import javax.xml.parsers.ParserConfigurationException;
|
||||
import java.io.IOException;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Xml Reader class for Boat XML used for the race
|
||||
*/
|
||||
public class BoatXMLReader extends XMLReader implements BoatDataSource {
|
||||
|
||||
private final Map<Integer, Boat> boatMap = new HashMap<>();
|
||||
private final Map<Integer, Mark> markerMap = new HashMap<>();
|
||||
|
||||
/**
|
||||
* Polars table to assign to each boat.
|
||||
*/
|
||||
Polars boatPolars;
|
||||
|
||||
|
||||
/**
|
||||
* Constructor for Boat XML
|
||||
*
|
||||
* @param filePath Name/path of file to read. Read as a resource.
|
||||
* @param boatPolars polars used by the boats
|
||||
* @throws IOException error
|
||||
* @throws SAXException error
|
||||
* @throws ParserConfigurationException error
|
||||
*/
|
||||
public BoatXMLReader(String filePath, Polars boatPolars) throws IOException, SAXException, ParserConfigurationException {
|
||||
super(filePath);
|
||||
this.boatPolars = boatPolars;
|
||||
read();
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the XML
|
||||
*/
|
||||
public void read() {
|
||||
readSettings();
|
||||
readShapes();
|
||||
readBoats();
|
||||
}
|
||||
|
||||
/**
|
||||
* Read the Boats
|
||||
*/
|
||||
private void readBoats() {
|
||||
Element nBoats = (Element) doc.getElementsByTagName("Boats").item(0);
|
||||
for (int i = 0; i < nBoats.getChildNodes().getLength(); i++) {
|
||||
Node boat = nBoats.getChildNodes().item(i);
|
||||
if (boat.getNodeName().equals("Boat")) {
|
||||
readBoatNode(boat);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ignored data
|
||||
*/
|
||||
private void readShapes() {
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Ignored data
|
||||
*/
|
||||
private void readSettings() {
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the node (XMl data node) is a Yacht or not
|
||||
* @param boatNode Node from the XML
|
||||
* @return Whether the node is a yacht node or not
|
||||
*/
|
||||
private boolean isYachtNode(Node boatNode) {
|
||||
return boatNode.getAttributes().getNamedItem("Type").getTextContent().toLowerCase().equals("yacht");
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads the information about one boat
|
||||
* Ignored values: ShapeID, StoweName, HullNum, Skipper, Type
|
||||
*/
|
||||
private void readBoatNode(Node boatNode) {
|
||||
int sourceID = Integer.parseInt(boatNode.getAttributes().getNamedItem("SourceID").getTextContent());
|
||||
String name = boatNode.getAttributes().getNamedItem("BoatName").getTextContent();
|
||||
|
||||
if (isYachtNode(boatNode)) readYacht(boatNode, sourceID, name);
|
||||
else readMark(boatNode, sourceID, name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read a Yacht Node
|
||||
* @param boatNode Node to be read
|
||||
* @param sourceID Source ID of the Yacht
|
||||
* @param name Name of the Boat
|
||||
*/
|
||||
private void readYacht(Node boatNode, int sourceID, String name) {
|
||||
String shortName = boatNode.getAttributes().getNamedItem("ShortName").getTextContent();
|
||||
if (exists(boatNode, "Country")) {
|
||||
String country = boatNode.getAttributes().getNamedItem("Country").getTextContent();
|
||||
boatMap.put(sourceID, new Boat(sourceID, name, country, this.boatPolars));
|
||||
} else {
|
||||
boatMap.put(sourceID, new Boat(sourceID, name, shortName, this.boatPolars));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Read Marker Boats
|
||||
* @param boatNode Node to be read
|
||||
* @param sourceID Source ID of the boat
|
||||
* @param name Name of the Marker Boat
|
||||
*/
|
||||
private void readMark(Node boatNode, int sourceID, String name) {
|
||||
Node nCoord = ((Element)boatNode).getElementsByTagName("GPSposition").item(0);
|
||||
double x = Double.parseDouble(nCoord.getAttributes().getNamedItem("X").getTextContent());
|
||||
double y = Double.parseDouble(nCoord.getAttributes().getNamedItem("Y").getTextContent());
|
||||
Mark mark = new Mark(sourceID, name, new GPSCoordinate(y,x));
|
||||
markerMap.put(sourceID, mark);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the boats that are going to participate in this race
|
||||
* @return Dictionary of boats that are to participate in this race indexed by SourceID
|
||||
*/
|
||||
@Override
|
||||
public Map<Integer, Boat> getBoats() {
|
||||
return boatMap;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the marker BOats that are participating in this race
|
||||
* @return Dictionary of the Markers BOats that are in this race indexed by their Source ID.
|
||||
*/
|
||||
@Override
|
||||
public Map<Integer, Mark> getMarkerBoats() {
|
||||
return markerMap;
|
||||
}
|
||||
}
|
||||
@@ -1,105 +0,0 @@
|
||||
package seng302.DataInput;
|
||||
|
||||
import seng302.Exceptions.InvalidPolarFileException;
|
||||
import seng302.Model.Bearing;
|
||||
import seng302.Model.Polars;
|
||||
|
||||
import java.io.*;
|
||||
import java.util.ArrayList;
|
||||
|
||||
|
||||
/**
|
||||
* Responsible for parsing a polar data file, and creating a Polar data object.
|
||||
*/
|
||||
public class PolarParser {
|
||||
|
||||
|
||||
/**
|
||||
* Given a filename, this function parses it and generates a Polar object, which can be queried for polar information.
|
||||
* @param filename The filename to load and read data from (loaded as a resource).
|
||||
* @return A Polar table containing data from the given file.
|
||||
*/
|
||||
public static Polars parse(String filename) throws InvalidPolarFileException {
|
||||
//Temporary table to return later.
|
||||
Polars polarTable = new Polars();
|
||||
|
||||
|
||||
//Open the file for reading.
|
||||
InputStream fileStream = PolarParser.class.getClassLoader().getResourceAsStream(filename);
|
||||
if (fileStream == null) {
|
||||
throw new InvalidPolarFileException("Could not open polar data file: " + filename);
|
||||
}
|
||||
//Wrap it with buffered input stream to set encoding and buffer.
|
||||
InputStreamReader in = null;
|
||||
try {
|
||||
in = new InputStreamReader(fileStream, "UTF-8");
|
||||
} catch (UnsupportedEncodingException e) {
|
||||
throw new InvalidPolarFileException("Unsupported encoding: UTF-8", e);
|
||||
}
|
||||
BufferedReader inputStream = new BufferedReader(in);
|
||||
|
||||
|
||||
//We expect the polar data file to have the column headings:
|
||||
// Tws, Twa0, Bsp0, Twa1, Bsp1, UpTwa, UpBsp, Twa2, Bsp2, Twa3, Bsp3, Twa4, Bsp4, Twa5, Bsp5, Twa6, Bsp6, DnTwa, DnBsp, Twa7, Bsp7
|
||||
//and to have 7 rows of data.
|
||||
//Angles are expected to be in degrees, and velocities in knots.
|
||||
|
||||
|
||||
//We read data rows, and split them into arrays of elements.
|
||||
ArrayList<String[]> dataRows = new ArrayList<>(7);
|
||||
try {
|
||||
//Heading row.
|
||||
//We skip the heading row by reading it.
|
||||
String headingRow = inputStream.readLine();
|
||||
|
||||
//Data rows.
|
||||
while (inputStream.ready()) {
|
||||
//Read line.
|
||||
String dataRow = inputStream.readLine();
|
||||
|
||||
//Split line.
|
||||
String[] dataElements = dataRow.split(",");
|
||||
|
||||
//Add to collection.
|
||||
dataRows.add(dataElements);
|
||||
|
||||
}
|
||||
|
||||
} catch (IOException e) {
|
||||
throw new InvalidPolarFileException("Could not read from polar data file: " + filename, e);
|
||||
}
|
||||
|
||||
//Finished reading in data, now we need to construct polar rows and table from it.
|
||||
//For each row...
|
||||
int rowNumber = 0;
|
||||
for (String[] row : dataRows) {
|
||||
|
||||
//For each pair of columns (the pair is angle, speed).
|
||||
//We start at column 1 since column 0 is the wind speed column.
|
||||
for (int i = 1; i < row.length; i += 2) {
|
||||
|
||||
//Add angle+speed=velocity estimate to polar table.
|
||||
try {
|
||||
|
||||
//Add the polar value to the polar table
|
||||
double windSpeedKnots = Double.parseDouble(row[0]);
|
||||
double angleDegrees = Double.parseDouble(row[i]);
|
||||
Bearing angle = Bearing.fromDegrees(angleDegrees);
|
||||
double boatSpeedKnots = Double.parseDouble(row[i + 1]);
|
||||
polarTable.addEstimate(windSpeedKnots, angle, boatSpeedKnots);
|
||||
|
||||
} catch (NumberFormatException e) {
|
||||
throw new InvalidPolarFileException("Could not convert (Row,Col): (" + rowNumber + "," + i +") = " + row[i] + " to a double.", e);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
//Increment row number.
|
||||
rowNumber++;
|
||||
|
||||
}
|
||||
|
||||
return polarTable;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
package seng302.DataInput;
|
||||
|
||||
import seng302.Model.Boat;
|
||||
import seng302.Model.CompoundMark;
|
||||
import seng302.Model.GPSCoordinate;
|
||||
import seng302.Model.Leg;
|
||||
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Data Class for a Race
|
||||
*/
|
||||
public interface RaceDataSource {
|
||||
List<Boat> getBoats();
|
||||
|
||||
List<Leg> getLegs();
|
||||
|
||||
List<GPSCoordinate> getBoundary();
|
||||
|
||||
List<CompoundMark> getCompoundMarks();
|
||||
|
||||
int getRaceId();
|
||||
|
||||
String getRaceType();
|
||||
|
||||
ZonedDateTime getZonedDateTime();
|
||||
|
||||
GPSCoordinate getMapTopLeft();
|
||||
|
||||
GPSCoordinate getMapBottomRight();
|
||||
}
|
||||
@@ -1,288 +0,0 @@
|
||||
package seng302.DataInput;
|
||||
|
||||
import org.w3c.dom.Element;
|
||||
import org.w3c.dom.NamedNodeMap;
|
||||
import org.w3c.dom.Node;
|
||||
import org.w3c.dom.NodeList;
|
||||
import org.xml.sax.SAXException;
|
||||
import seng302.Exceptions.StreamedCourseXMLException;
|
||||
import seng302.Model.*;
|
||||
|
||||
import javax.xml.parsers.ParserConfigurationException;
|
||||
import java.io.IOException;
|
||||
import java.text.ParseException;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.time.format.DateTimeFormatter;
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* XML Reader that reads in the race data required for this race
|
||||
*/
|
||||
public class RaceXMLReader extends XMLReader implements RaceDataSource {
|
||||
private static final double COORDINATEPADDING = 0.000;
|
||||
private GPSCoordinate mapTopLeft, mapBottomRight;
|
||||
private final List<GPSCoordinate> boundary = new ArrayList<>();
|
||||
private final Map<Integer,Element> compoundMarkMap = new HashMap<>();
|
||||
private final Map<Integer, Boat> participants = new HashMap<>();
|
||||
private final List<Leg> legs = new ArrayList<>();
|
||||
private final List<CompoundMark> compoundMarks = new ArrayList<>();
|
||||
private ZonedDateTime creationTimeDate;
|
||||
private ZonedDateTime raceStartTime;
|
||||
private int raceID;
|
||||
private String raceType;
|
||||
private boolean postpone;
|
||||
|
||||
private Map<Integer, Boat> boats;
|
||||
private Map<Integer, Mark> marks;
|
||||
|
||||
/**
|
||||
* Constructor for Streamed Race XML
|
||||
* @param filePath path of the file
|
||||
* @param boatData data for boats in race
|
||||
* @throws IOException error
|
||||
* @throws SAXException error
|
||||
* @throws ParserConfigurationException error
|
||||
* @throws ParseException error
|
||||
* @throws StreamedCourseXMLException error
|
||||
*/
|
||||
public RaceXMLReader(String filePath, BoatDataSource boatData) throws IOException, SAXException, ParserConfigurationException, ParseException, StreamedCourseXMLException {
|
||||
this(filePath, boatData, true);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Constructor for Streamed Race XML
|
||||
* @param filePath file path to read
|
||||
* @param boatData data of the boats in race
|
||||
* @param read whether or not to read and store the files straight away.
|
||||
* @throws IOException error
|
||||
* @throws SAXException error
|
||||
* @throws ParserConfigurationException error
|
||||
* @throws ParseException error
|
||||
* @throws StreamedCourseXMLException error
|
||||
*/
|
||||
public RaceXMLReader(String filePath, BoatDataSource boatData, boolean read) throws IOException, SAXException, ParserConfigurationException, ParseException, StreamedCourseXMLException {
|
||||
super(filePath);
|
||||
this.boats = boatData.getBoats();
|
||||
this.marks = boatData.getMarkerBoats();
|
||||
if (read) {
|
||||
read();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* reads
|
||||
* @throws StreamedCourseXMLException error
|
||||
*/
|
||||
private void read() throws StreamedCourseXMLException {
|
||||
readRace();
|
||||
readParticipants();
|
||||
readCourse();
|
||||
}
|
||||
|
||||
/**
|
||||
* reads a race
|
||||
*/
|
||||
private void readRace() {
|
||||
DateTimeFormatter dateFormat = DateTimeFormatter.ISO_OFFSET_DATE_TIME;
|
||||
Element settings = (Element) doc.getElementsByTagName("Race").item(0);
|
||||
NamedNodeMap raceTimeTag = doc.getElementsByTagName("RaceStartTime").item(0).getAttributes();
|
||||
|
||||
if (raceTimeTag.getNamedItem("Time") != null) dateFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ssZ");
|
||||
|
||||
|
||||
raceID = Integer.parseInt(getTextValueOfNode(settings, "RaceID"));
|
||||
raceType = getTextValueOfNode(settings, "RaceType");
|
||||
|
||||
creationTimeDate = ZonedDateTime.parse(getTextValueOfNode(settings, "CreationTimeDate"), dateFormat);
|
||||
|
||||
if (raceTimeTag.getNamedItem("Time") != null) raceStartTime = ZonedDateTime.parse(raceTimeTag.getNamedItem("Time").getTextContent(), dateFormat);
|
||||
else raceStartTime = ZonedDateTime.parse(raceTimeTag.getNamedItem("Start").getTextContent(), dateFormat);
|
||||
|
||||
postpone = Boolean.parseBoolean(raceTimeTag.getNamedItem("Postpone").getTextContent());
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads in the participants for htis race
|
||||
*/
|
||||
private void readParticipants() {
|
||||
Element nParticipants = (Element) doc.getElementsByTagName("Participants").item(0);
|
||||
nParticipants.getChildNodes().getLength();
|
||||
for (int i = 0; i < nParticipants.getChildNodes().getLength(); i++) {
|
||||
int sourceID;
|
||||
Node yacht = nParticipants.getChildNodes().item(i);
|
||||
if (yacht.getNodeName().equals("Yacht")) {
|
||||
if (exists(yacht, "SourceID")) {
|
||||
sourceID = Integer.parseInt(yacht.getAttributes().getNamedItem("SourceID").getTextContent());
|
||||
participants.put(sourceID, boats.get(sourceID));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* reads a course
|
||||
* @throws StreamedCourseXMLException error
|
||||
*/
|
||||
private void readCourse() throws StreamedCourseXMLException {
|
||||
readCompoundMarks();
|
||||
readCompoundMarkSequence();
|
||||
readCourseLimit();
|
||||
}
|
||||
|
||||
/**
|
||||
* Indexes CompoundMark elements by their ID for use in generating the course, and populates list of Markers.
|
||||
* @see CompoundMark
|
||||
*/
|
||||
private void readCompoundMarks() throws StreamedCourseXMLException {
|
||||
Element nCourse = (Element) doc.getElementsByTagName("Course").item(0);
|
||||
for(int i = 0; i < nCourse.getChildNodes().getLength(); i++) {
|
||||
Node compoundMark = nCourse.getChildNodes().item(i);
|
||||
if(compoundMark.getNodeName().equals("CompoundMark")) {
|
||||
int compoundMarkID = getCompoundMarkID((Element) compoundMark);
|
||||
compoundMarkMap.put(compoundMarkID, (Element)compoundMark);
|
||||
compoundMarks.add(getCompoundMark(compoundMarkID));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates a CompoundMark from the CompoundMark element with given ID.
|
||||
* @param compoundMarkID index of required CompoundMark element
|
||||
* @return generated CompoundMark
|
||||
* @throws StreamedCourseXMLException if CompoundMark element contains unhandled number of compoundMarks
|
||||
* @see CompoundMark
|
||||
*/
|
||||
private CompoundMark getCompoundMark(int compoundMarkID) throws StreamedCourseXMLException {
|
||||
Element compoundMark = compoundMarkMap.get(compoundMarkID);
|
||||
NodeList nMarks = compoundMark.getElementsByTagName("Mark");
|
||||
CompoundMark marker;
|
||||
|
||||
switch(nMarks.getLength()) {
|
||||
case 1: marker = new CompoundMark(getMark((Element)nMarks.item(0)));
|
||||
break;
|
||||
case 2: marker = new CompoundMark(getMark((Element)nMarks.item(0)), getMark((Element)nMarks.item(1))); break;
|
||||
default: throw new StreamedCourseXMLException();
|
||||
}
|
||||
|
||||
return marker;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a mark from an Element
|
||||
* @param mark Element the mark is suppose to be part of
|
||||
* @return a Mark that existed in the element
|
||||
*/
|
||||
private Mark getMark(Element mark) {
|
||||
int sourceID = Integer.parseInt(mark.getAttribute("SourceID"));
|
||||
return marks.get(sourceID);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads "compoundMarkID" attribute of CompoundMark or Corner element
|
||||
* @param element with "compoundMarkID" attribute
|
||||
* @return value of "compoundMarkID" attribute
|
||||
*/
|
||||
private int getCompoundMarkID(Element element) {
|
||||
return Integer.parseInt(element.getAttribute("CompoundMarkID"));
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads "name" attribute of CompoundMark element with corresponding CompoundMarkID
|
||||
* @param compoundMarkID unique ID for CompoundMark element
|
||||
* @return value of "name" attribute
|
||||
*/
|
||||
private String getCompoundMarkName(int compoundMarkID) {
|
||||
return compoundMarkMap.get(compoundMarkID).getAttribute("Name");
|
||||
}
|
||||
|
||||
/**
|
||||
* Populates list of legs given CompoundMarkSequence element and referenced CompoundMark elements.
|
||||
* @throws StreamedCourseXMLException if compoundMarks cannot be resolved from CompoundMark
|
||||
*/
|
||||
private void readCompoundMarkSequence() throws StreamedCourseXMLException {
|
||||
Element nCompoundMarkSequence = (Element) doc.getElementsByTagName("CompoundMarkSequence").item(0);
|
||||
NodeList nCorners = nCompoundMarkSequence.getElementsByTagName("Corner");
|
||||
Element markXML = (Element)nCorners.item(0);
|
||||
CompoundMark lastCompoundMark = getCompoundMark(getCompoundMarkID(markXML));
|
||||
String legName = getCompoundMarkName(getCompoundMarkID(markXML));
|
||||
for(int i = 1; i < nCorners.getLength(); i++) {
|
||||
markXML = (Element)nCorners.item(i);
|
||||
CompoundMark currentCompoundMark = getCompoundMark(getCompoundMarkID(markXML));
|
||||
legs.add(new Leg(legName, lastCompoundMark, currentCompoundMark, i-1));
|
||||
lastCompoundMark = currentCompoundMark;
|
||||
legName = getCompoundMarkName(getCompoundMarkID(markXML));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads the boundary limits of the course
|
||||
*/
|
||||
private void readCourseLimit() {
|
||||
Element nCourseLimit = (Element) doc.getElementsByTagName("CourseLimit").item(0);
|
||||
for(int i = 0; i < nCourseLimit.getChildNodes().getLength(); i++) {
|
||||
Node limit = nCourseLimit.getChildNodes().item(i);
|
||||
if (limit.getNodeName().equals("Limit")) {
|
||||
double lat = Double.parseDouble(limit.getAttributes().getNamedItem("Lat").getTextContent());
|
||||
double lon = Double.parseDouble(limit.getAttributes().getNamedItem("Lon").getTextContent());
|
||||
boundary.add(new GPSCoordinate(lat, lon));
|
||||
}
|
||||
}
|
||||
|
||||
double maxLatitude = boundary.stream().max(Comparator.comparingDouble(GPSCoordinate::getLatitude)).get().getLatitude() + COORDINATEPADDING;
|
||||
double maxLongitude = boundary.stream().max(Comparator.comparingDouble(GPSCoordinate::getLongitude)).get().getLongitude() + COORDINATEPADDING;
|
||||
double minLatitude = boundary.stream().min(Comparator.comparingDouble(GPSCoordinate::getLatitude)).get().getLatitude() + COORDINATEPADDING;
|
||||
double minLongitude = boundary.stream().min(Comparator.comparingDouble(GPSCoordinate::getLongitude)).get().getLongitude() + COORDINATEPADDING;
|
||||
|
||||
mapTopLeft = new GPSCoordinate(minLatitude, minLongitude);
|
||||
mapBottomRight = new GPSCoordinate(maxLatitude, maxLongitude);
|
||||
}
|
||||
|
||||
public List<GPSCoordinate> getBoundary() {
|
||||
return boundary;
|
||||
}
|
||||
|
||||
public GPSCoordinate getMapTopLeft() {
|
||||
return mapTopLeft;
|
||||
}
|
||||
|
||||
public GPSCoordinate getMapBottomRight() {
|
||||
return mapBottomRight;
|
||||
}
|
||||
|
||||
public List<Leg> getLegs() {
|
||||
return legs;
|
||||
}
|
||||
|
||||
public List<CompoundMark> getCompoundMarks() { return compoundMarks; }
|
||||
|
||||
public Double getPadding() {
|
||||
return COORDINATEPADDING;
|
||||
}
|
||||
|
||||
public ZonedDateTime getCreationTimeDate() {
|
||||
return creationTimeDate;
|
||||
}
|
||||
|
||||
public ZonedDateTime getZonedDateTime() {
|
||||
return raceStartTime;
|
||||
}
|
||||
|
||||
public int getRaceId() {
|
||||
return raceID;
|
||||
}
|
||||
|
||||
public String getRaceType() {
|
||||
return raceType;
|
||||
}
|
||||
|
||||
public boolean isPostpone() {
|
||||
return postpone;
|
||||
}
|
||||
|
||||
public List<Boat> getBoats() {
|
||||
return new ArrayList<>(participants.values());
|
||||
}
|
||||
}
|
||||
@@ -1,112 +0,0 @@
|
||||
package seng302.DataInput;
|
||||
|
||||
import org.w3c.dom.Document;
|
||||
import org.w3c.dom.Element;
|
||||
import org.w3c.dom.Node;
|
||||
import org.xml.sax.InputSource;
|
||||
import org.xml.sax.SAXException;
|
||||
|
||||
import javax.xml.parsers.DocumentBuilder;
|
||||
import javax.xml.parsers.DocumentBuilderFactory;
|
||||
import javax.xml.parsers.ParserConfigurationException;
|
||||
import javax.xml.transform.*;
|
||||
import javax.xml.transform.dom.DOMSource;
|
||||
import javax.xml.transform.stream.StreamResult;
|
||||
import java.io.IOException;
|
||||
import java.io.StringReader;
|
||||
import java.io.StringWriter;
|
||||
|
||||
/**
|
||||
* Base Reader for XML Files
|
||||
*/
|
||||
public abstract class XMLReader {
|
||||
|
||||
protected Document doc;
|
||||
|
||||
/**
|
||||
* Read in XML file
|
||||
* @param filePath filepath for XML file
|
||||
* @throws ParserConfigurationException If a document builder cannot be created.
|
||||
* @throws IOException If any IO errors occur while parsing the XML file.
|
||||
* @throws SAXException If any parse error occurs while parsing.
|
||||
*/
|
||||
public XMLReader(String filePath) throws ParserConfigurationException, IOException, SAXException {
|
||||
|
||||
InputSource fXmlFile;
|
||||
if (filePath.contains("<")) {
|
||||
fXmlFile = new InputSource();
|
||||
fXmlFile.setCharacterStream(new StringReader(filePath));
|
||||
|
||||
} else {
|
||||
fXmlFile = new InputSource(getClass().getClassLoader().getResourceAsStream(filePath));
|
||||
}
|
||||
|
||||
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
|
||||
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
|
||||
doc = dBuilder.parse(fXmlFile);
|
||||
doc.getDocumentElement().normalize();
|
||||
}
|
||||
|
||||
/**
|
||||
* Alternate constructor
|
||||
* @param xmlFile File to be read
|
||||
* @param isWholeFile boolean value whether entire file is being passed
|
||||
*/
|
||||
public XMLReader(String xmlFile, Boolean isWholeFile) {
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Return Document data of the read-in XML
|
||||
* @return XML document
|
||||
*/
|
||||
public Document getDocument() {
|
||||
return doc;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get content of a tag in an element
|
||||
* @param n Element to read tags from
|
||||
* @param tagName Name of the tag
|
||||
* @return Content of the tag
|
||||
*/
|
||||
public String getTextValueOfNode(Element n, String tagName) {
|
||||
return n.getElementsByTagName(tagName).item(0).getTextContent();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get attributes for an element
|
||||
* @param n Element to read attributes from
|
||||
* @param attr Attributes of element
|
||||
* @return Attributes of element
|
||||
*/
|
||||
public String getAttribute(Element n, String attr) {
|
||||
return n.getAttribute(attr);
|
||||
}
|
||||
|
||||
protected boolean exists(Node node, String attribute) {
|
||||
return node.getAttributes().getNamedItem(attribute) != null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the contents of the XML FILe.
|
||||
* @param document holds all xml information
|
||||
* @return String representation of document
|
||||
* @throws TransformerException when document is malformed, and cannot be turned into a string
|
||||
*/
|
||||
public static String getContents(Document document) throws TransformerException {
|
||||
DOMSource source = new DOMSource(document);
|
||||
|
||||
TransformerFactory transformerFactory = TransformerFactory.newInstance();
|
||||
Transformer transformer = transformerFactory.newTransformer();
|
||||
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
|
||||
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
|
||||
|
||||
StringWriter stringWriter = new StringWriter();
|
||||
StreamResult result = new StreamResult(stringWriter);
|
||||
transformer.transform(source, result);
|
||||
|
||||
return stringWriter.toString();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,14 +0,0 @@
|
||||
package seng302.Exceptions;
|
||||
|
||||
/**
|
||||
* An exception thrown when we cannot generate Boats.xml and send an XML message.
|
||||
*/
|
||||
public class InvalidBoatDataException extends RuntimeException {
|
||||
|
||||
public InvalidBoatDataException() {
|
||||
}
|
||||
|
||||
public InvalidBoatDataException(String message) {
|
||||
super(message);
|
||||
}
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
package seng302.Exceptions;
|
||||
|
||||
/**
|
||||
* An exception thrown when we cannot parse a polar data file.
|
||||
*/
|
||||
public class InvalidPolarFileException extends RuntimeException {
|
||||
|
||||
/**
|
||||
* Constructs the exception with a given message.
|
||||
* @param message Message to store.
|
||||
*/
|
||||
public InvalidPolarFileException(String message) {
|
||||
super(message);
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs the exception with a given message and cause.
|
||||
* @param message Message to store.
|
||||
* @param cause Cause to store.
|
||||
*/
|
||||
public InvalidPolarFileException(String message, Throwable cause) {
|
||||
super(message, cause);
|
||||
}
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
package seng302.Exceptions;
|
||||
|
||||
/**
|
||||
* Exception thrown when we cannot generate Race.xml data, and send an XML message.
|
||||
*/
|
||||
public class InvalidRaceDataException extends RuntimeException {
|
||||
public InvalidRaceDataException() {
|
||||
}
|
||||
|
||||
public InvalidRaceDataException(String message) {
|
||||
super(message);
|
||||
}
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
package seng302.Exceptions;
|
||||
|
||||
/**
|
||||
* Created by cbt24 on 25/04/17.
|
||||
*/
|
||||
public class StreamedCourseXMLException extends Throwable {
|
||||
}
|
||||
@@ -1,251 +0,0 @@
|
||||
package seng302;
|
||||
|
||||
|
||||
import seng302.Networking.BinaryMessageEncoder;
|
||||
import seng302.Networking.MessageEncoders.RaceVisionByteEncoder;
|
||||
import seng302.Networking.MessageEncoders.XMLMessageEncoder;
|
||||
import seng302.Networking.Messages.BoatLocation;
|
||||
import seng302.Networking.Messages.Enums.MessageType;
|
||||
import seng302.Networking.Messages.RaceStatus;
|
||||
import seng302.Networking.Messages.XMLMessage;
|
||||
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
|
||||
import java.util.concurrent.ArrayBlockingQueue;
|
||||
|
||||
/**
|
||||
* TCP server to send race information to connected clients.
|
||||
*/
|
||||
public class MockOutput implements Runnable
|
||||
{
|
||||
///Timestamp of the last sent heartbeat message.
|
||||
private long lastHeartbeatTime;
|
||||
|
||||
///Period for the heartbeat - that is, how often we send it.
|
||||
private double heartbeatPeriod = 5.0;
|
||||
|
||||
///Port to expose server on.
|
||||
private int serverPort = 4942;
|
||||
///Socket used to listen for clients on.
|
||||
private ServerSocket serverSocket;
|
||||
///Socket used to communicate with a client.
|
||||
private Socket mockSocket;
|
||||
///Output stream which wraps around mockSocket outstream.
|
||||
private DataOutputStream outToVisualiser;
|
||||
|
||||
///A queue that contains items that are waiting to be sent.
|
||||
private ArrayBlockingQueue<byte[]> messagesToSendQueue = new ArrayBlockingQueue<>(99999999);
|
||||
|
||||
///Sequence numbers used in messages.
|
||||
private short messageNumber = 1;
|
||||
private short xmlSequenceNumber = 1;
|
||||
private int heartbeatSequenceNum = 1;
|
||||
private int boatLocationSequenceNumber = 1;
|
||||
private int raceStatusSequenceNumber = 1;
|
||||
|
||||
///Strings containing XML data as strings.
|
||||
private String raceXml;
|
||||
private String regattaXml;
|
||||
private String boatsXml;
|
||||
|
||||
private boolean stop = false; //whether or not hte thread keeps running
|
||||
|
||||
/**
|
||||
* Ctor.
|
||||
* @throws IOException if server socket cannot be opened.
|
||||
*/
|
||||
public MockOutput() throws IOException {
|
||||
lastHeartbeatTime = System.currentTimeMillis();
|
||||
serverSocket = new ServerSocket(serverPort);
|
||||
|
||||
}
|
||||
/**
|
||||
* Calculates the time since last heartbeat message, in seconds.
|
||||
* @return Time since last heartbeat message, in seconds.
|
||||
*/
|
||||
private double timeSinceHeartbeat() {
|
||||
long now = System.currentTimeMillis();
|
||||
return (now - lastHeartbeatTime) / 1000.0;
|
||||
}
|
||||
|
||||
//returns the heartbeat message
|
||||
|
||||
/**
|
||||
* Increment the heartbeat value
|
||||
* @return message for heartbeat data
|
||||
*/
|
||||
private byte[] heartbeat(){
|
||||
byte[] heartbeatMessage = RaceVisionByteEncoder.heartBeat(heartbeatSequenceNum);
|
||||
heartbeatSequenceNum++;
|
||||
BinaryMessageEncoder binaryMessageEncoder = new BinaryMessageEncoder(MessageType.HEARTBEAT, System.currentTimeMillis(), messageNumber, (short)heartbeatMessage.length, heartbeatMessage);
|
||||
messageNumber++;
|
||||
return binaryMessageEncoder.getFullMessage();
|
||||
}
|
||||
|
||||
/**
|
||||
* Used to give the mockOutput an xml string to be made into a message and sent
|
||||
* @param xmlString the xml string to send
|
||||
* @param messageType the kind of xml string, values given in AC35 spec (5 regatta, 6 race, 7 boat)
|
||||
*/
|
||||
public synchronized void parseXMLString(String xmlString, int messageType){
|
||||
XMLMessageEncoder encoder = new XMLMessageEncoder(messageNumber, System.currentTimeMillis(), messageType, xmlSequenceNumber,(short) xmlString.length(), xmlString);
|
||||
//iterates the sequence numbers
|
||||
xmlSequenceNumber++;
|
||||
byte[] encodedXML = encoder.encode();
|
||||
|
||||
BinaryMessageEncoder binaryMessageEncoder = new BinaryMessageEncoder(MessageType.XMLMESSAGE, System.currentTimeMillis(), messageNumber, (short)encodedXML.length, encodedXML);
|
||||
//iterates the message number
|
||||
messageNumber++;
|
||||
|
||||
addMessageToBufferToSend(binaryMessageEncoder.getFullMessage());
|
||||
}
|
||||
|
||||
/**
|
||||
* Used to give the mocOutput information about boat location to be made into a message and sent
|
||||
* @param sourceID id of the boat
|
||||
* @param lat latitude of boat
|
||||
* @param lon longitude of boat
|
||||
* @param heading heading of boat
|
||||
* @param speed speed of boat
|
||||
* @param time historical time of race
|
||||
*/
|
||||
public synchronized void parseBoatLocation(int sourceID, double lat, double lon, double heading, double speed, long time){
|
||||
|
||||
BoatLocation boatLocation = new BoatLocation(sourceID, lat, lon, boatLocationSequenceNumber, heading, speed, time);
|
||||
//iterates the sequence number
|
||||
boatLocationSequenceNumber++;
|
||||
|
||||
//encodeds the messages
|
||||
byte[] encodedBoatLoc = RaceVisionByteEncoder.boatLocation(boatLocation);
|
||||
|
||||
//encodeds the full message with header
|
||||
BinaryMessageEncoder binaryMessageEncoder = new BinaryMessageEncoder(MessageType.BOATLOCATION, System.currentTimeMillis(), messageNumber, (short)encodedBoatLoc.length,
|
||||
encodedBoatLoc);
|
||||
|
||||
//iterates the message number
|
||||
messageNumber++;
|
||||
|
||||
addMessageToBufferToSend(binaryMessageEncoder.getFullMessage());
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse the race status data and add it to the buffer to be sent
|
||||
* @param raceStatus race status to parses
|
||||
*/
|
||||
public synchronized void parseRaceStatus(RaceStatus raceStatus){
|
||||
|
||||
//iterates the sequence number
|
||||
raceStatusSequenceNumber++;
|
||||
|
||||
//encodeds the messages
|
||||
byte[] encodedRaceStatus = RaceVisionByteEncoder.raceStatus(raceStatus);
|
||||
|
||||
//encodeds the full message with header
|
||||
BinaryMessageEncoder binaryMessageEncoder = new BinaryMessageEncoder(MessageType.RACESTATUS, System.currentTimeMillis(), messageNumber, (short)encodedRaceStatus.length,
|
||||
encodedRaceStatus);
|
||||
|
||||
//iterates the message number
|
||||
messageNumber++;
|
||||
|
||||
addMessageToBufferToSend(binaryMessageEncoder.getFullMessage());
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a message to the buffer to be sent
|
||||
* @param messagesToSendBuffer message to add to the buffer
|
||||
*/
|
||||
private synchronized void addMessageToBufferToSend(byte[] messagesToSendBuffer) {
|
||||
this.messagesToSendQueue.add(messagesToSendBuffer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sending loop of the Server
|
||||
*/
|
||||
public void run() {
|
||||
|
||||
try {
|
||||
while (!stop){
|
||||
System.out.println("Waiting for a connection...");//TEMP DEBUG REMOVE
|
||||
mockSocket = serverSocket.accept();
|
||||
|
||||
outToVisualiser = new DataOutputStream(mockSocket.getOutputStream());
|
||||
|
||||
if (boatsXml == null || regattaXml == null || raceXml == null){
|
||||
try {
|
||||
Thread.sleep(500);
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
parseXMLString(raceXml, XMLMessage.XMLTypeRace);
|
||||
parseXMLString(regattaXml, XMLMessage.XMLTypeRegatta);
|
||||
parseXMLString(boatsXml, XMLMessage.XMLTypeBoat);
|
||||
|
||||
|
||||
while(true) {
|
||||
try {
|
||||
//Sends a heartbeat every so often.
|
||||
if (timeSinceHeartbeat() >= heartbeatPeriod) {
|
||||
outToVisualiser.write(heartbeat());
|
||||
lastHeartbeatTime = System.currentTimeMillis();
|
||||
}
|
||||
|
||||
//Checks the buffer to see if there is anything to send.
|
||||
while (messagesToSendQueue.size() > 0) {
|
||||
//Grabs message from head of queue.
|
||||
byte[] binaryMessage = messagesToSendQueue.remove();
|
||||
|
||||
//sends the message to the visualiser
|
||||
outToVisualiser.write(binaryMessage);
|
||||
|
||||
}
|
||||
}catch(SocketException e){
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
public void stop(){
|
||||
stop = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the Race XML to send
|
||||
* @param raceXml XML to send to the CLient
|
||||
*/
|
||||
public void setRaceXml(String raceXml) {
|
||||
this.raceXml = raceXml;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the Regatta XMl to send
|
||||
* @param regattaXml XML to send to CLient
|
||||
*/
|
||||
public void setRegattaXml(String regattaXml) {
|
||||
this.regattaXml = regattaXml;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the Boats XML to send
|
||||
* @param boatsXml XMl to send to the CLient
|
||||
*/
|
||||
public void setBoatsXml(String boatsXml) {
|
||||
this.boatsXml = boatsXml;
|
||||
}
|
||||
|
||||
public static void main(String argv[]) throws Exception
|
||||
{
|
||||
MockOutput client = new MockOutput();
|
||||
client.run();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,130 +0,0 @@
|
||||
package seng302.Model;
|
||||
|
||||
/**
|
||||
* This represents an angle.
|
||||
* Has functions to return angle as either degrees or radians.
|
||||
*/
|
||||
public class Angle implements Comparable<Angle> {
|
||||
|
||||
/**
|
||||
* The angle stored in this object.
|
||||
* Degrees.
|
||||
*/
|
||||
private double degrees;
|
||||
|
||||
|
||||
/**
|
||||
* Ctor.
|
||||
* Don't use this.
|
||||
* This is protected because you need to use the static helper functions {@link #fromDegrees(double)} and {@link #fromRadians(double)} to construct an Angle object.
|
||||
*
|
||||
* @param degrees The value, in degrees, to initialize this Angle object with.
|
||||
*/
|
||||
protected Angle(double degrees) {
|
||||
this.degrees = degrees;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Constructs an Angle object from an angle value in degrees.
|
||||
* @param degrees Angle value in degrees.
|
||||
* @return Angle object.
|
||||
*/
|
||||
public static Angle fromDegrees(double degrees) {
|
||||
Angle angle = new Angle(degrees);
|
||||
return angle;
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs an Angle object from an angle value in radians.
|
||||
* @param radians Angle value in radians.
|
||||
* @return Angle object.
|
||||
*/
|
||||
public static Angle fromRadians(double radians) {
|
||||
return Angle.fromDegrees(Math.toDegrees(radians));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Returns the value of this Angle object, in degrees.
|
||||
* @return The value of this Angle object, in degrees.
|
||||
*/
|
||||
public double degrees() {
|
||||
return this.degrees;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the value of this Angle object, in radians.
|
||||
* @return The value of this Angle object, in radians.
|
||||
*/
|
||||
public double radians() {
|
||||
return Math.toRadians(this.degrees);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if two Angle objects have equal values.
|
||||
* @param obj Other angle object to compare.
|
||||
* @return True if they are equal, false otherwise.
|
||||
*/
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
//Cast other side.
|
||||
Angle other = (Angle) obj;
|
||||
|
||||
//Compare values.
|
||||
if (this.degrees() == other.degrees()) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns an int describing the ordering between this angle object, and another.
|
||||
* @param o Other angle to compare to.
|
||||
* @return {@literal int < 0} if this angle is less than the other angle, {@literal int > 0} if this angle is greater than the other angle, and {@literal int = 0} if this angle is equal to the other angle,
|
||||
*/
|
||||
@Override
|
||||
public int compareTo(Angle o) {
|
||||
|
||||
if (this.degrees() < o.degrees()) {
|
||||
return -1;
|
||||
} else if (this.degrees() > o.degrees()) {
|
||||
return 1;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Converts an angle to an angle in a given periodic interval (e.g., degrees have a periodic interval of 360, radians have a periodic interval of 2Pi) of [lowerBound, upperBound).
|
||||
* @param angle The angle to convert.
|
||||
* @param lowerBound The lower bound of the interval.
|
||||
* @param upperBound The upper bound of the interval.
|
||||
* @param period The period of the interval.
|
||||
* @return The angle in the desired periodic interval.
|
||||
*/
|
||||
public static double toPeriodicInterval(double angle, double lowerBound, double upperBound, double period) {
|
||||
|
||||
|
||||
while (angle >= upperBound) {
|
||||
//Too large.
|
||||
angle -= period;
|
||||
}
|
||||
|
||||
while (angle < lowerBound) {
|
||||
//Too small.
|
||||
angle += period;
|
||||
}
|
||||
|
||||
return angle;
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,68 +0,0 @@
|
||||
package seng302.Model;
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Represents an azimuth.
|
||||
* If treated as an absolute azimuth this is the angle between north and a target point.
|
||||
* If treated as a relative azimuth, this is the angle between from one target point to the other.
|
||||
* It has the interval [-180, 180) degrees, and clockwise is positive.
|
||||
*/
|
||||
public class Azimuth extends Angle{
|
||||
|
||||
|
||||
/**
|
||||
* Ctor.
|
||||
* This is protected because you need to use the static helper functions {@link #fromDegrees(double)} and {@link #fromRadians(double)} to construct an Azimuth object.
|
||||
*
|
||||
* @param degrees The value, in degrees, to initialize this Azimuth object with.
|
||||
*/
|
||||
protected Azimuth(double degrees) {
|
||||
super(degrees);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Converts an angle in degrees into an angle in degrees in the correct interval for an azimuth - [-180, 180).
|
||||
* E.g., converts -183 to 177, or converts 250 to -110, or converts 180 to -180.
|
||||
* @param degrees Degree value to convert.
|
||||
* @return Degree value in interval [-180, 180).
|
||||
*/
|
||||
public static double toAzimuthInterval(double degrees) {
|
||||
|
||||
return Angle.toPeriodicInterval(degrees, -180d, 180d, 360d);
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs an Azimuth object from an angle value in degrees.
|
||||
* @param degrees Azimuth value in degrees.
|
||||
* @return Azimuth object.
|
||||
*/
|
||||
public static Azimuth fromDegrees(double degrees) {
|
||||
//Ensure the angle is in the correct interval.
|
||||
double degreesInInterval = Azimuth.toAzimuthInterval(degrees);
|
||||
|
||||
Azimuth azimuth = new Azimuth(degreesInInterval);
|
||||
return azimuth;
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs an Azimuth object from an angle value in radians.
|
||||
* @param radians Azimuth value in radians.
|
||||
* @return Azimuth object.
|
||||
*/
|
||||
public static Azimuth fromRadians(double radians) {
|
||||
return Azimuth.fromDegrees(Math.toDegrees(radians));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Constructs an Azimuth object from a Bearing object.
|
||||
* @param bearing Bearing object to read value from.
|
||||
* @return Azimuth object.
|
||||
*/
|
||||
public static Azimuth fromBearing(Bearing bearing) {
|
||||
return Azimuth.fromDegrees(bearing.degrees());
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,66 +0,0 @@
|
||||
package seng302.Model;
|
||||
|
||||
/**
|
||||
* Represents a bearing. Also known as a heading.
|
||||
* If treated as an absolute bearing this is the angle between north and a target point.
|
||||
* If treated as a relative bearing, this is the angle between from one target point to the other.
|
||||
* Has the interval [0, 360) degrees, and clockwise is positive.
|
||||
*/
|
||||
public class Bearing extends Angle {
|
||||
|
||||
|
||||
/**
|
||||
* Ctor.
|
||||
* This is protected because you need to use the static helper functions {@link #fromDegrees(double)} and {@link #fromRadians(double)} to construct a Bearing object.
|
||||
*
|
||||
* @param degrees The value, in degrees, to initialize this Bearing object with.
|
||||
*/
|
||||
protected Bearing(double degrees) {
|
||||
super(degrees);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Converts an angle in degrees into an angle in degrees in the correct interval for a bearing - [0, 360).
|
||||
* E.g., converts -183 to 177, or converts 425 to 65.
|
||||
* @param degrees Degree value to convert.
|
||||
* @return Degree value in interval [0, 360).
|
||||
*/
|
||||
public static double toBearingInterval(double degrees) {
|
||||
|
||||
return Angle.toPeriodicInterval(degrees, -0d, 360d, 360d);
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs a Bearing object from an angle value in degrees.
|
||||
* @param degrees Bearing value in degrees.
|
||||
* @return Bearing object.
|
||||
*/
|
||||
public static Bearing fromDegrees(double degrees) {
|
||||
//Ensure the angle is in the correct interval.
|
||||
double degreesInInterval = Bearing.toBearingInterval(degrees);
|
||||
|
||||
Bearing bearing = new Bearing(degreesInInterval);
|
||||
return bearing;
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs a Bearing object from an angle value in radians.
|
||||
* @param radians Bearing value in radians.
|
||||
* @return Bearing object.
|
||||
*/
|
||||
public static Bearing fromRadians(double radians) {
|
||||
return Bearing.fromDegrees(Math.toDegrees(radians));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Constructs a Bearing object from an Azimuth object.
|
||||
* @param azimuth Azimuth object to read value from.
|
||||
* @return Bearing object.
|
||||
*/
|
||||
public static Bearing fromAzimuth(Azimuth azimuth) {
|
||||
return Bearing.fromDegrees(azimuth.degrees());
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,454 +0,0 @@
|
||||
package seng302.Model;
|
||||
|
||||
import seng302.Constants;
|
||||
import seng302.Networking.Messages.Enums.BoatStatusEnum;
|
||||
|
||||
|
||||
/**
|
||||
* Boat Model that is used to store information on the boats that are running in the race.
|
||||
*/
|
||||
public class Boat {
|
||||
/**
|
||||
* The name of the boat/team.
|
||||
*/
|
||||
private String name;
|
||||
|
||||
/**
|
||||
* The current speed of the boat, in knots.
|
||||
* TODO knots
|
||||
*/
|
||||
private double currentSpeed;
|
||||
|
||||
/**
|
||||
* The current bearing/heading of the boat.
|
||||
*/
|
||||
private Bearing bearing;
|
||||
|
||||
/**
|
||||
* The current position of the boat.
|
||||
*/
|
||||
private GPSCoordinate currentPosition;
|
||||
|
||||
/**
|
||||
* The country or team abbreviation of the boat.
|
||||
*/
|
||||
private String country;
|
||||
|
||||
/**
|
||||
* The source ID of the boat.
|
||||
* This uniquely identifies an entity during a race.
|
||||
*/
|
||||
private int sourceID;
|
||||
|
||||
/**
|
||||
* The leg of the race that the boat is currently on.
|
||||
*/
|
||||
private Leg currentLeg;
|
||||
|
||||
/**
|
||||
* The distance, in meters, that the boat has travelled in the current leg.
|
||||
* TODO meters
|
||||
*/
|
||||
private double distanceTravelledInLeg;
|
||||
|
||||
/**
|
||||
* The time, in milliseconds, that has elapsed during the current leg.
|
||||
* TODO milliseconds
|
||||
*/
|
||||
private long timeElapsedInCurrentLeg;
|
||||
|
||||
/**
|
||||
* The timestamp, in milliseconds, of when the boat finished the race.
|
||||
* Is -1 if it hasn't finished.
|
||||
* TODO milliseconds
|
||||
*/
|
||||
private long timeFinished = -1;
|
||||
|
||||
/**
|
||||
* The current status of the boat.
|
||||
*/
|
||||
private BoatStatusEnum status;
|
||||
|
||||
/**
|
||||
* This stores a boat's polars table.
|
||||
* Can be used to calculate VMG.
|
||||
*/
|
||||
private Polars polars;
|
||||
|
||||
/**
|
||||
* This stores the milliseconds since the boat has changed its tack, to allow for only updating the tack every X milliseconds.
|
||||
* TODO milliseconds
|
||||
*/
|
||||
private long timeSinceTackChange = 0;
|
||||
|
||||
private long estimatedTime = 0;
|
||||
|
||||
|
||||
/**
|
||||
* Constructs a boat object with a given sourceID, name, country/team abbreviation, and polars table.
|
||||
*
|
||||
* @param sourceID The id of the boat
|
||||
* @param name The name of the Boat.
|
||||
* @param country The abbreviation or country code for the boat.
|
||||
* @param polars The polars table to use for this boat.
|
||||
*/
|
||||
public Boat(int sourceID, String name, String country, Polars polars) {
|
||||
this.country = country;
|
||||
this.name = name;
|
||||
this.sourceID = sourceID;
|
||||
this.polars = polars;
|
||||
|
||||
this.bearing = Bearing.fromDegrees(0d);
|
||||
|
||||
this.status = BoatStatusEnum.UNDEFINED;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Calculate the bearing of the boat to its next marker.
|
||||
* @return The bearing to the next marker.
|
||||
*/
|
||||
public Bearing calculateBearingToNextMarker() {
|
||||
|
||||
//Get the start and end points.
|
||||
GPSCoordinate currentPosition = this.getCurrentPosition();
|
||||
GPSCoordinate nextMarkerPosition = this.getCurrentLeg().getEndCompoundMark().getAverageGPSCoordinate();
|
||||
|
||||
//Calculate bearing.
|
||||
Bearing bearing = GPSCoordinate.calculateBearing(currentPosition, nextMarkerPosition);
|
||||
|
||||
return bearing;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the distance between the boat and its target marker in nautical miles.
|
||||
* @return The distance (in nautical miles) between the boat and its target marker.
|
||||
*/
|
||||
public double calculateDistanceToNextMarker() {
|
||||
|
||||
//Get start and end markers.
|
||||
GPSCoordinate startPosition = this.getCurrentPosition();
|
||||
|
||||
//When boats finish, their "current leg" doesn't have an end marker.
|
||||
if (this.getCurrentLeg().getEndCompoundMark() == null) {
|
||||
return 0d;
|
||||
}
|
||||
|
||||
GPSCoordinate endMarker = this.getCurrentLeg().getEndCompoundMark().getAverageGPSCoordinate();
|
||||
|
||||
|
||||
//Calculate distance.
|
||||
double distanceNauticalMiles = GPSCoordinate.calculateDistanceNauticalMiles(startPosition, endMarker);
|
||||
|
||||
return distanceNauticalMiles;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the name of the boat/team.
|
||||
* @return Name of the boat/team.
|
||||
*/
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the name of the boat/team.
|
||||
* @param name Name of the boat/team.
|
||||
*/
|
||||
public void setName(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the current speed of the boat, in knots.
|
||||
* @return The current speed of the boat, in knots.
|
||||
*/
|
||||
public double getCurrentSpeed() {
|
||||
return currentSpeed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the speed of the boat, in knots.
|
||||
* @param currentSpeed The new speed of the boat, in knots.
|
||||
*/
|
||||
public void setCurrentSpeed(double currentSpeed) {
|
||||
this.currentSpeed = currentSpeed;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Gets the country/team abbreviation of the boat.
|
||||
* @return The country/team abbreviation of the boat.
|
||||
*/
|
||||
public String getCountry() {
|
||||
return country;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the country/team abbreviation of the boat.
|
||||
* @param country The new country/team abbreviation for the boat.
|
||||
*/
|
||||
public void setCountry(String country) {
|
||||
this.country = country;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the source ID of the boat.
|
||||
* @return The source ID of the boat.
|
||||
*/
|
||||
public int getSourceID() {
|
||||
return sourceID;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the source ID of the boat.
|
||||
* @param sourceID The new source ID for the boat.
|
||||
*/
|
||||
public void setSourceID(int sourceID) {
|
||||
this.sourceID = sourceID;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current leg of the race the boat is in.
|
||||
* @return The current leg of the race the boat is in.
|
||||
*/
|
||||
public Leg getCurrentLeg() {
|
||||
return currentLeg;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the current leg of the race the boat is in.
|
||||
* Clears time elapsed in current leg and distance travelled in current leg.
|
||||
* @param currentLeg The new leg of the race the boat is in.
|
||||
*/
|
||||
public void setCurrentLeg(Leg currentLeg) {
|
||||
this.currentLeg = currentLeg;
|
||||
this.setTimeElapsedInCurrentLeg(0);
|
||||
this.setDistanceTravelledInLeg(0);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the distance, in meters, the boat has travelled in the current leg.
|
||||
* @return The distance, in meters, the boat has travelled in the current leg.
|
||||
*/
|
||||
public double getDistanceTravelledInLeg() {
|
||||
return distanceTravelledInLeg;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the distance, in meters, the boat has travelled in the current leg.
|
||||
* @param distanceTravelledInLeg The distance, in meters, the boat has travelled in the current leg.
|
||||
*/
|
||||
public void setDistanceTravelledInLeg(double distanceTravelledInLeg) {
|
||||
this.distanceTravelledInLeg = distanceTravelledInLeg;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the current position of the boat.
|
||||
* @return The current position of the boat.
|
||||
*/
|
||||
public GPSCoordinate getCurrentPosition() {
|
||||
return currentPosition;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the current position of the boat.
|
||||
* @param currentPosition The new position for the boat.
|
||||
*/
|
||||
public void setCurrentPosition(GPSCoordinate currentPosition) {
|
||||
this.currentPosition = currentPosition;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Gets the timestamp, in milliseconds, at which the boat finished the race.
|
||||
* @return The timestamp, in milliseconds, at which the boat finished the race.
|
||||
*/
|
||||
public long getTimeFinished() {
|
||||
return timeFinished;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the timestamp, in milliseconds, at which the boat finished the race.
|
||||
* @param timeFinished The timestamp, in milliseconds, at which the boat finished the race.
|
||||
*/
|
||||
public void setTimeFinished(long timeFinished) {
|
||||
this.timeFinished = timeFinished;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Returns the current bearing of the boat.
|
||||
* @return The current bearing of the boat.
|
||||
*/
|
||||
public Bearing getBearing() {
|
||||
return bearing;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the current bearing of the boat.
|
||||
* @param bearing The new bearing of the boat.
|
||||
*/
|
||||
public void setBearing(Bearing bearing) {
|
||||
this.bearing = bearing;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the polars table for this boat.
|
||||
* @return The polars table for this boat.
|
||||
*/
|
||||
public Polars getPolars() {
|
||||
return polars;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the polars table for this boat.
|
||||
* @param polars The new polars table for this boat.
|
||||
*/
|
||||
public void setPolars(Polars polars) {
|
||||
this.polars = polars;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the time since the boat changed its tack, in milliseconds.
|
||||
* @return Time since the boat changed its tack, in milliseconds.
|
||||
*/
|
||||
public long getTimeSinceTackChange() {
|
||||
return timeSinceTackChange;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the time since the boat changed it's tack, in milliseconds.
|
||||
* @param timeSinceTackChange Time since the boat changed its tack, in milliseconds.
|
||||
*/
|
||||
public void setTimeSinceTackChange(long timeSinceTackChange) {
|
||||
this.timeSinceTackChange = timeSinceTackChange;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the time, in milliseconds, that has elapsed since the boat started the current leg.
|
||||
* @return The time, in milliseconds, that has elapsed since the boat started the current leg.
|
||||
*/
|
||||
public long getTimeElapsedInCurrentLeg() {
|
||||
return timeElapsedInCurrentLeg;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the time, in milliseconds, that has elapsed since the boat started the current leg.
|
||||
* @param timeElapsedInCurrentLeg The new time, in milliseconds, that has elapsed since the boat started the current leg.
|
||||
*/
|
||||
public void setTimeElapsedInCurrentLeg(long timeElapsedInCurrentLeg) {
|
||||
this.timeElapsedInCurrentLeg = timeElapsedInCurrentLeg;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the status of the boat.
|
||||
* @return The sttus of the boat.
|
||||
*/
|
||||
public BoatStatusEnum getStatus() {
|
||||
return status;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the status of the boat.
|
||||
* @param status The new status of the boat.
|
||||
*/
|
||||
public void setStatus(BoatStatusEnum status) {
|
||||
this.status = status;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Moves the boat meters forward in the direction that it is facing
|
||||
* @param meters The number of meters to move forward.
|
||||
* @param milliseconds The number of milliseconds to advance the boat's timers by.
|
||||
*/
|
||||
public void moveForwards(double meters, long milliseconds) {
|
||||
|
||||
|
||||
//Update the boat's time since last tack.
|
||||
this.setTimeSinceTackChange(this.getTimeSinceTackChange() + milliseconds);
|
||||
|
||||
//Update the time into the current leg.
|
||||
this.setTimeElapsedInCurrentLeg(this.getTimeElapsedInCurrentLeg() + milliseconds);
|
||||
|
||||
//Update the distance into the current leg.
|
||||
this.setDistanceTravelledInLeg(this.getDistanceTravelledInLeg() + meters);
|
||||
|
||||
//Updates the current position of the boat.
|
||||
GPSCoordinate newPosition = GPSCoordinate.calculateNewPosition(this.getCurrentPosition(), meters, Azimuth.fromBearing(this.getBearing()));
|
||||
this.setCurrentPosition(newPosition);
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the boats speed and bearing to those in the given VMG.
|
||||
* @param newVMG The new VMG to use for the boat - contains speed and bearing.
|
||||
*/
|
||||
public void setVMG(VMG newVMG) {
|
||||
this.setBearing(newVMG.getBearing());
|
||||
this.setCurrentSpeed(newVMG.getSpeed());
|
||||
this.setTimeSinceTackChange(0);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the number of nautical miles the boat will travel in a given time slice.
|
||||
* E.g., in 53 milliseconds a boat may travel 0.0002 nautical miles.
|
||||
* @param timeSlice The timeslice to use.
|
||||
* @return The distance travelled, in nautical miles, over the given timeslice.
|
||||
*/
|
||||
public double calculateNauticalMilesTravelled(long timeSlice) {
|
||||
|
||||
//The proportion of one hour the current timeslice is.
|
||||
//This will be a low fractional number, so we need to go from long -> double.
|
||||
double hourProportion = ((double) timeSlice) / Constants.OneHourMilliseconds;
|
||||
|
||||
//Calculates the distance travelled, in nautical miles, in the current timeslice.
|
||||
//distanceTravelledNM = speed (nm p hr) * time taken to update loop
|
||||
double distanceTravelledNM = this.getCurrentSpeed() * hourProportion;
|
||||
|
||||
return distanceTravelledNM;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the number of meters the boat will travel in a given time slice.
|
||||
* E.g., in 53 milliseconds a boat may travel 0.02 meters.
|
||||
* @param timeSlice The timeslice to use.
|
||||
* @return The distance travelled, in meters, over the given timeslice.
|
||||
*/
|
||||
public double calculateMetersTravelled(long timeSlice) {
|
||||
|
||||
//Calculate the distance travelled, in nautical miles.
|
||||
double distanceTravelledNM = this.calculateNauticalMilesTravelled(timeSlice);
|
||||
|
||||
//Convert to meters.
|
||||
double distanceTravelledMeters = distanceTravelledNM * Constants.NMToMetersConversion;
|
||||
|
||||
return distanceTravelledMeters;
|
||||
}
|
||||
|
||||
public long getEstimatedTime() {
|
||||
return estimatedTime;
|
||||
}
|
||||
|
||||
public void setEstimatedTime(long estimatedTime) {
|
||||
this.estimatedTime = estimatedTime;
|
||||
}
|
||||
}
|
||||
@@ -1,110 +0,0 @@
|
||||
package seng302.Model;
|
||||
|
||||
|
||||
/**
|
||||
* Represents a compound mark - that is, either one or two individual marks which form a single compound mark.
|
||||
*/
|
||||
public class CompoundMark {
|
||||
|
||||
/**
|
||||
* The first mark in the compound mark.
|
||||
*/
|
||||
private Mark mark1;
|
||||
|
||||
/**
|
||||
* The second mark in the compound mark.
|
||||
*/
|
||||
private Mark mark2;
|
||||
|
||||
/**
|
||||
* The average coordinate of the compound mark.
|
||||
*/
|
||||
private GPSCoordinate averageGPSCoordinate;
|
||||
|
||||
|
||||
/**
|
||||
* Constructs a compound mark from a single mark.
|
||||
* @param mark1 The individual mark that comprises this compound mark.
|
||||
*/
|
||||
public CompoundMark(Mark mark1) {
|
||||
this.mark1 = mark1;
|
||||
this.averageGPSCoordinate = calculateAverage();
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Constructs a compound mark from a pair of marks.
|
||||
* @param mark1 The first individual mark that comprises this compound mark.
|
||||
* @param mark2 The second individual mark that comprises this compound mark.
|
||||
*/
|
||||
public CompoundMark(Mark mark1, Mark mark2) {
|
||||
this.mark1 = mark1;
|
||||
this.mark2 = mark2;
|
||||
this.averageGPSCoordinate = calculateAverage();
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the first mark of the compound mark.
|
||||
* @return The first mark of the compound mark.
|
||||
*/
|
||||
public Mark getMark1() {
|
||||
return mark1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the second mark of the compound mark.
|
||||
* @return The second mark of the compound mark.
|
||||
*/
|
||||
public Mark getMark2() {
|
||||
return mark2;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the position of the first mark in the compound mark.
|
||||
* @return The position of the first mark in the compound mark.
|
||||
*/
|
||||
public GPSCoordinate getMark1Position() {
|
||||
return mark1.getPosition();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the position of the second mark in the compound mark.
|
||||
* @return The position of the second mark in the compound mark.
|
||||
*/
|
||||
public GPSCoordinate getMark2Position() {
|
||||
return mark2.getPosition();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the average coordinate of the compound mark.
|
||||
* @return The average coordinate of the compound mark.
|
||||
*/
|
||||
public GPSCoordinate getAverageGPSCoordinate() {
|
||||
return averageGPSCoordinate;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the average coordinate of the compound mark.
|
||||
* @return The average coordinate of the compound mark.
|
||||
*/
|
||||
private GPSCoordinate calculateAverage() {
|
||||
|
||||
//If the compound mark only contains one mark, the average is simply the first mark's position.
|
||||
if (this.mark2 == null) {
|
||||
return this.getMark1Position();
|
||||
}
|
||||
|
||||
|
||||
//Otherwise, calculate the average of both marks.
|
||||
GPSCoordinate averageCoordinate = GPSCoordinate.calculateAverageCoordinate(this.getMark1Position(), this.getMark2Position());
|
||||
|
||||
return averageCoordinate;
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,82 +0,0 @@
|
||||
package seng302.Model;
|
||||
|
||||
import org.xml.sax.SAXException;
|
||||
import seng302.DataInput.*;
|
||||
import seng302.Exceptions.StreamedCourseXMLException;
|
||||
import seng302.MockOutput;
|
||||
import seng302.Networking.Messages.Enums.MessageType;
|
||||
|
||||
import javax.xml.parsers.ParserConfigurationException;
|
||||
import java.io.*;
|
||||
import java.text.ParseException;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.time.format.DateTimeFormatter;
|
||||
|
||||
|
||||
/**
|
||||
* A Race Event, this holds all of the race's information as well as handling the connection to its clients.
|
||||
*/
|
||||
public class Event {
|
||||
|
||||
String raceXML;
|
||||
String regattaXML;
|
||||
String boatXML;
|
||||
Polars boatPolars;
|
||||
MockOutput mockOutput;
|
||||
|
||||
public Event(String raceXML, String regattaXML, String boatXML, Polars boatPolars) {
|
||||
|
||||
this.raceXML = getRaceXMLAtCurrentTime(raceXML);
|
||||
this.boatXML = boatXML;
|
||||
this.regattaXML = regattaXML;
|
||||
this.boatPolars = boatPolars;
|
||||
try {
|
||||
mockOutput = new MockOutput();
|
||||
new Thread(mockOutput).start();
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends the initial race data and then begins race simulation
|
||||
*/
|
||||
public void start() {
|
||||
try {
|
||||
sendXMLs();
|
||||
Race newRace = new Race(new RaceXMLReader(this.raceXML, new BoatXMLReader(boatXML, this.boatPolars)), mockOutput);
|
||||
new Thread((newRace)).start();
|
||||
|
||||
} catch (ParserConfigurationException | IOException | SAXException | ParseException | StreamedCourseXMLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends out each xml string, via the mock output
|
||||
*/
|
||||
private void sendXMLs() {
|
||||
|
||||
mockOutput.setRegattaXml(regattaXML);
|
||||
mockOutput.parseXMLString(regattaXML, MessageType.XMLMESSAGE.getValue());
|
||||
|
||||
mockOutput.setRaceXml(raceXML);
|
||||
mockOutput.parseXMLString(raceXML, MessageType.XMLMESSAGE.getValue());
|
||||
|
||||
mockOutput.setBoatsXml(boatXML);
|
||||
mockOutput.parseXMLString(boatXML, MessageType.XMLMESSAGE.getValue());
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the xml description of the race to show the race was created now, and starts in 3 minutes
|
||||
* @param raceXML
|
||||
* @return String containing edited xml
|
||||
*/
|
||||
private String getRaceXMLAtCurrentTime(String raceXML) {
|
||||
DateTimeFormatter dateFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ssZ");
|
||||
ZonedDateTime creationTime = ZonedDateTime.now();
|
||||
return raceXML.replace("CREATION_TIME", dateFormat.format(creationTime))
|
||||
.replace("START_TIME", dateFormat.format(creationTime.plusMinutes(3)));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,517 +0,0 @@
|
||||
package seng302.Model;
|
||||
|
||||
import javafx.util.Pair;
|
||||
import org.geotools.referencing.GeodeticCalculator;
|
||||
import seng302.Constants;
|
||||
|
||||
import java.awt.geom.Point2D;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* GPS Coordinate for the world map, containing a longitude and latitude.
|
||||
* Created by esa46 on 15/03/17.
|
||||
*/
|
||||
public class GPSCoordinate {
|
||||
|
||||
/**
|
||||
* The latitude of the coordinate.
|
||||
*/
|
||||
private double latitude;
|
||||
|
||||
/**
|
||||
* The longitude of the coordinate.
|
||||
*/
|
||||
private double longitude;
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Constructs a GPSCoordinate from a latitude and longitude value.
|
||||
* @param latitude Latitude the coordinate is located at.
|
||||
* @param longitude Longitude that the coordinate is located at.
|
||||
*/
|
||||
public GPSCoordinate(double latitude, double longitude) {
|
||||
this.latitude = latitude;
|
||||
this.longitude = longitude;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Gets the Latitude that the Coordinate is at.
|
||||
*
|
||||
* @return Returns the latitude of the Coordinate.
|
||||
*/
|
||||
public double getLatitude() {
|
||||
return latitude;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the Longitude that the Coordinate is at.
|
||||
*
|
||||
* @return Returns the longitude of the Coordinate.
|
||||
*/
|
||||
public double getLongitude() {
|
||||
return longitude;
|
||||
}
|
||||
|
||||
/**
|
||||
* To String method of the Coordinate in the form Latitude: $f, Longitude: $f.
|
||||
*
|
||||
* @return A String representation of the GPSCoordinate Class.
|
||||
*/
|
||||
public String toString() {
|
||||
return String.format("Latitude: %f, Longitude: %f", latitude, longitude);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
if (this == o) return true;
|
||||
if (o == null || getClass() != o.getClass()) return false;
|
||||
|
||||
GPSCoordinate that = (GPSCoordinate) o;
|
||||
|
||||
if (Math.abs(this.latitude - that.latitude) > 1e-7) return false;
|
||||
return (Math.abs(this.longitude - that.longitude) < 1e-7);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
int result;
|
||||
long temp;
|
||||
temp = Double.doubleToLongBits(latitude);
|
||||
result = (int) (temp ^ (temp >>> 32));
|
||||
temp = Double.doubleToLongBits(longitude);
|
||||
result = 31 * result + (int) (temp ^ (temp >>> 32));
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Calculates min and max values and passed it to calculate if coordinate is in the boundary
|
||||
* @param coordinate coordinate of interest
|
||||
* @param boundary List of points which make a boundary
|
||||
* @return true if coordinate is in the boundary
|
||||
*/
|
||||
public static boolean isInsideBoundary(GPSCoordinate coordinate, List<GPSCoordinate> boundary) {
|
||||
int length = boundary.size();
|
||||
|
||||
boolean inside = false;
|
||||
|
||||
// Check if inside using ray casting algorithm
|
||||
for (int i = 0, j = length - 1; i < length; j = i++) {
|
||||
if (intersects(boundary.get(i), boundary.get(j), coordinate)) {
|
||||
inside = !inside;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
return inside;
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates if the coordinate is in the boundary
|
||||
* @param coordinate coordinate of interest
|
||||
* @param boundary List of points which make a boundary
|
||||
* @param minValues max GPS
|
||||
* @param maxValues min GPS
|
||||
* @return true if coordinate is in the boundary
|
||||
*/
|
||||
public static boolean isInsideBoundary(GPSCoordinate coordinate, List<GPSCoordinate> boundary, GPSCoordinate minValues, GPSCoordinate maxValues) {
|
||||
double minLat = minValues.getLatitude();
|
||||
double minLon = minValues.getLongitude();
|
||||
double maxLat = maxValues.getLatitude();
|
||||
double maxLon = maxValues.getLongitude();
|
||||
double coordinateLat = coordinate.getLatitude();
|
||||
double coordinateLon = coordinate.getLongitude();
|
||||
// End computation early
|
||||
if (coordinateLat <= minLat || coordinateLat >= maxLat || coordinateLon <= minLon || coordinateLon >= maxLon) {
|
||||
return false;
|
||||
} else {
|
||||
return isInsideBoundary(coordinate, boundary);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Helper function to find if a point is in a boundary
|
||||
* @param boundaryA The first coordinate of the boundary.
|
||||
* @param boundaryB The second coordinate of the boundary.
|
||||
* @param coordinate The coordinate to test.
|
||||
* @return true if a line from the point intersects the two boundary points
|
||||
*/
|
||||
private static boolean intersects(GPSCoordinate boundaryA, GPSCoordinate boundaryB, GPSCoordinate coordinate) {
|
||||
double boundaryALat = boundaryA.getLatitude();
|
||||
double boundaryALon = boundaryA.getLongitude();
|
||||
double boundaryBLat = boundaryB.getLatitude();
|
||||
double boundaryBLon = boundaryB.getLongitude();
|
||||
double coordinateLat = coordinate.getLatitude();
|
||||
double coordinateLon = coordinate.getLongitude();
|
||||
|
||||
if (boundaryALat > boundaryBLat) {
|
||||
return intersects(boundaryB, boundaryA, coordinate);
|
||||
}
|
||||
if (coordinateLat == boundaryALat || coordinateLat == boundaryBLat) {
|
||||
// Move coordinate off intersection line
|
||||
coordinateLat += 1e-9;
|
||||
}
|
||||
if (coordinateLat > boundaryBLat || coordinateLat < boundaryALat || coordinateLon > Double.max(boundaryALon, boundaryBLon)) {
|
||||
return false;
|
||||
}
|
||||
if (coordinateLon < Double.min(boundaryALon, boundaryBLon)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
double aRatio = (coordinateLat - boundaryALat) / (coordinateLon - boundaryALon);
|
||||
double bRatio = (coordinateLat - boundaryBLat) / (coordinateLon - boundaryBLon);
|
||||
return aRatio >= bRatio;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the azimuth between two points.
|
||||
* @param start The starting point.
|
||||
* @param end The ending point.
|
||||
* @return The azimuth from the start point to the end point.
|
||||
*/
|
||||
public static Azimuth calculateAzimuth(GPSCoordinate start, GPSCoordinate end) {
|
||||
|
||||
GeodeticCalculator calc = new GeodeticCalculator();
|
||||
|
||||
calc.setStartingGeographicPoint(start.getLongitude(), start.getLatitude());
|
||||
calc.setDestinationGeographicPoint(end.getLongitude(), end.getLatitude());
|
||||
|
||||
return Azimuth.fromDegrees(calc.getAzimuth());
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the bearing between two points.
|
||||
* @param start The starting point.
|
||||
* @param end The ending point.
|
||||
* @return The Bearing from the start point to the end point.
|
||||
*/
|
||||
public static Bearing calculateBearing(GPSCoordinate start, GPSCoordinate end) {
|
||||
|
||||
//Calculates the azimuth between the two points.
|
||||
Azimuth azimuth = GPSCoordinate.calculateAzimuth(start, end);
|
||||
|
||||
//And converts it into a bearing.
|
||||
return Bearing.fromAzimuth(azimuth);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the distance, in meters, between two points.
|
||||
* Note: all other distance calculations (e.g., nautical miles between two points) should use this, and convert from meters to their desired unit.
|
||||
* @param start The starting point.
|
||||
* @param end The ending point.
|
||||
* @return The distance, in meters, between the two given points.
|
||||
*/
|
||||
public static double calculateDistanceMeters(GPSCoordinate start, GPSCoordinate end) {
|
||||
|
||||
GeodeticCalculator calc = new GeodeticCalculator();
|
||||
|
||||
calc.setStartingGeographicPoint(start.getLongitude(), start.getLatitude());
|
||||
calc.setDestinationGeographicPoint(end.getLongitude(), end.getLatitude());
|
||||
|
||||
double distanceMeters = calc.getOrthodromicDistance();
|
||||
|
||||
return distanceMeters;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the distance, in nautical miles, between two points.
|
||||
* @param start The starting point.
|
||||
* @param end The ending point.
|
||||
* @return The distance, in nautical miles, between the two given points.
|
||||
*/
|
||||
public static double calculateDistanceNauticalMiles(GPSCoordinate start, GPSCoordinate end) {
|
||||
//Find distance in meters.
|
||||
double distanceMeters = GPSCoordinate.calculateDistanceMeters(start, end);
|
||||
|
||||
//Convert to nautical miles.
|
||||
double distanceNauticalMiles = distanceMeters / Constants.NMToMetersConversion;
|
||||
|
||||
return distanceNauticalMiles;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the GPS position an entity will be at, given a starting position, distance (in meters), and an azimuth.
|
||||
*
|
||||
* @param oldCoordinates GPS coordinates of the entity's starting position.
|
||||
* @param distanceMeters The distance in meters.
|
||||
* @param azimuth The entity's current azimuth.
|
||||
* @return The entity's new coordinate.
|
||||
*/
|
||||
public static GPSCoordinate calculateNewPosition(GPSCoordinate oldCoordinates, double distanceMeters, Azimuth azimuth) {
|
||||
|
||||
|
||||
GeodeticCalculator calc = new GeodeticCalculator();
|
||||
|
||||
//Set starting position.
|
||||
calc.setStartingGeographicPoint(oldCoordinates.getLongitude(), oldCoordinates.getLatitude());
|
||||
|
||||
//Set direction.
|
||||
calc.setDirection(azimuth.degrees(), distanceMeters);
|
||||
|
||||
//Get the destination.
|
||||
Point2D destinationPoint = calc.getDestinationGeographicPoint();
|
||||
|
||||
return new GPSCoordinate(destinationPoint.getY(), destinationPoint.getX());
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the average coordinate of two coordinates.
|
||||
* @param point1 The first coordinate to average.
|
||||
* @param point2 The second coordinate to average.
|
||||
* @return The average of the two coordinates.
|
||||
*/
|
||||
public static GPSCoordinate calculateAverageCoordinate(GPSCoordinate point1, GPSCoordinate point2) {
|
||||
|
||||
//Calculate distance between them.
|
||||
double distanceMeters = GPSCoordinate.calculateDistanceMeters(point1, point2);
|
||||
//We want the average, so get half the distance between points.
|
||||
distanceMeters = distanceMeters / 2d;
|
||||
|
||||
//Calculate azimuth between them.
|
||||
Azimuth azimuth = GPSCoordinate.calculateAzimuth(point1, point2);
|
||||
|
||||
//Calculate the middle coordinate.
|
||||
GPSCoordinate middleCoordinate = GPSCoordinate.calculateNewPosition(point1, distanceMeters, azimuth);
|
||||
|
||||
return middleCoordinate;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Takes a list of GPS coordinates describing a course boundary, and "shrinks" it inwards by 50m.
|
||||
* @param boundary The boundary of course.
|
||||
* @return A copy of the course boundary list, shrunk inwards by 50m.
|
||||
*/
|
||||
public static List<GPSCoordinate> getShrinkBoundary(List<GPSCoordinate> boundary) {
|
||||
|
||||
|
||||
double shrinkDistance = 50d;
|
||||
List<GPSCoordinate> shrunkBoundary = new ArrayList<>(boundary.size());
|
||||
//This is a list of edges that have been shrunk/shifted inwards.
|
||||
List<Pair<GPSCoordinate, GPSCoordinate>> shrunkEdges = new ArrayList<>();
|
||||
|
||||
|
||||
//We need to invert some of our operations depending if the boundary is clockwise or anti-clockwise.
|
||||
boolean isClockwise = GPSCoordinate.isClockwisePolygon(boundary);
|
||||
double clockwiseScaleFactor = 0;
|
||||
|
||||
if (isClockwise) {
|
||||
clockwiseScaleFactor = 1;
|
||||
} else {
|
||||
clockwiseScaleFactor = -1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
Starting at a vertex, face anti-clockwise along an adjacent edge.
|
||||
Replace the edge with a new, parallel edge placed at distance d to the "left" of the old one.
|
||||
Repeat for all edges.
|
||||
Find the intersections of the new edges to get the new vertices.
|
||||
Detect if you've become a crossed polynomial and decide what to do about it. Probably add a new vertex at the crossing-point and get rid of some old ones. I'm not sure whether there's a better way to detect this than just to compare every pair of non-adjacent edges to see if their intersection lies between both pairs of vertices.
|
||||
*/
|
||||
|
||||
//For the first (size-1) adjacent pairs.
|
||||
for (int i = 0; i < (boundary.size() - 1); i++) {
|
||||
|
||||
//Get the points.
|
||||
GPSCoordinate firstPoint = boundary.get(i);
|
||||
GPSCoordinate secondPoint = boundary.get(i + 1);
|
||||
|
||||
//Get the bearing between two adjacent points.
|
||||
Bearing bearing = GPSCoordinate.calculateBearing(firstPoint, secondPoint);
|
||||
|
||||
//Calculate angle perpendicular to bearing.
|
||||
Bearing perpendicularBearing = Bearing.fromDegrees(bearing.degrees() + (90d * clockwiseScaleFactor));
|
||||
|
||||
//Translate both first and second point by 50m, using this bearing. These form our inwards shifted edge.
|
||||
GPSCoordinate firstPointTranslated = GPSCoordinate.calculateNewPosition(firstPoint, shrinkDistance, Azimuth.fromBearing(perpendicularBearing));
|
||||
GPSCoordinate secondPointTranslated = GPSCoordinate.calculateNewPosition(secondPoint, shrinkDistance, Azimuth.fromBearing(perpendicularBearing));
|
||||
|
||||
//Add edge to list.
|
||||
shrunkEdges.add(new Pair<>(firstPointTranslated, secondPointTranslated));
|
||||
|
||||
}
|
||||
|
||||
//For the final adjacent pair, between the last and first point.
|
||||
//Get the points.
|
||||
GPSCoordinate firstPoint = boundary.get(boundary.size() - 1);
|
||||
GPSCoordinate secondPoint = boundary.get(0);
|
||||
|
||||
//Get the bearing between two adjacent points.
|
||||
Bearing bearing = GPSCoordinate.calculateBearing(firstPoint, secondPoint);
|
||||
|
||||
//Calculate angle perpendicular to bearing.
|
||||
Bearing perpendicularBearing = Bearing.fromDegrees(bearing.degrees() + (90d * clockwiseScaleFactor));
|
||||
|
||||
//Translate both first and second point by 50m, using this bearing. These form our inwards shifted edge.
|
||||
GPSCoordinate firstPointTranslated = GPSCoordinate.calculateNewPosition(firstPoint, shrinkDistance, Azimuth.fromBearing(perpendicularBearing));
|
||||
GPSCoordinate secondPointTranslated = GPSCoordinate.calculateNewPosition(secondPoint, shrinkDistance, Azimuth.fromBearing(perpendicularBearing));
|
||||
|
||||
//Add edge to list.
|
||||
shrunkEdges.add(new Pair<>(firstPointTranslated, secondPointTranslated));
|
||||
|
||||
|
||||
//We now have a list of edges that have been shifted inwards.
|
||||
//We need to find the intersections between adjacent vertices in our edge list. E.g., intersection between edge1-right, and edge2-left.
|
||||
|
||||
//For the first (size-1) adjacent pairs.
|
||||
for (int i = 0; i < (shrunkEdges.size() - 1); i++) {
|
||||
|
||||
//Get the pair of adjacent edges.
|
||||
Pair<GPSCoordinate, GPSCoordinate> edge1 = shrunkEdges.get(i);
|
||||
Pair<GPSCoordinate, GPSCoordinate> edge2 = shrunkEdges.get(i + 1);
|
||||
|
||||
//Get the x and y coordinates of first edge.
|
||||
double x1 = edge1.getKey().getLongitude();
|
||||
double x2 = edge1.getValue().getLongitude();
|
||||
double y1 = edge1.getKey().getLatitude();
|
||||
double y2 = edge1.getValue().getLatitude();
|
||||
|
||||
//Get the x and y coordinates of second edge.
|
||||
double x3 = edge2.getKey().getLongitude();
|
||||
double x4 = edge2.getValue().getLongitude();
|
||||
double y3 = edge2.getKey().getLatitude();
|
||||
double y4 = edge2.getValue().getLatitude();
|
||||
|
||||
//Find the equations for both edges.
|
||||
// y = a*x + b
|
||||
//First equation.
|
||||
double a1 = (y2 - y1) / (x2 - x1);
|
||||
double b1 = y1 - a1 * x1;
|
||||
|
||||
//Second equation.
|
||||
double a2 = (y4 - y3) / (x4 - x3);
|
||||
double b2 = y3 - a2 * x3;
|
||||
|
||||
|
||||
//Find intersecting x coordinate.
|
||||
// a1 * x + b1 = a2 * x + b2
|
||||
double x0 = -(b1 - b2) / (a1 - a2);
|
||||
//Find intersecting y coordinate.
|
||||
double y0 = x0 * a1 + b1;
|
||||
|
||||
//Add this to shrunk boundary list.
|
||||
GPSCoordinate coordinate = new GPSCoordinate(y0, x0);
|
||||
shrunkBoundary.add(coordinate);
|
||||
|
||||
}
|
||||
|
||||
|
||||
//For the final adjacent pair, between the last and first point.
|
||||
//Get the pair of adjacent edges.
|
||||
Pair<GPSCoordinate, GPSCoordinate> edge1 = shrunkEdges.get(shrunkEdges.size() - 1);
|
||||
Pair<GPSCoordinate, GPSCoordinate> edge2 = shrunkEdges.get(0);
|
||||
|
||||
//Get the x and y coordinates of first edge.
|
||||
double x1 = edge1.getKey().getLongitude();
|
||||
double x2 = edge1.getValue().getLongitude();
|
||||
double y1 = edge1.getKey().getLatitude();
|
||||
double y2 = edge1.getValue().getLatitude();
|
||||
|
||||
//Get the x and y coordinates of second edge.
|
||||
double x3 = edge2.getKey().getLongitude();
|
||||
double x4 = edge2.getValue().getLongitude();
|
||||
double y3 = edge2.getKey().getLatitude();
|
||||
double y4 = edge2.getValue().getLatitude();
|
||||
|
||||
//Find the equations for both edges.
|
||||
// y = a*x + b
|
||||
//First equation.
|
||||
double a1 = (y2 - y1) / (x2 - x1);
|
||||
double b1 = y1 - a1 * x1;
|
||||
|
||||
//Second equation.
|
||||
double a2 = (y4 - y3) / (x4 - x3);
|
||||
double b2 = y3 - a2 * x3;
|
||||
|
||||
|
||||
//Find intersecting x coordinate.
|
||||
// a1 * x + b1 = a2 * x + b2
|
||||
double x0 = -(b1 - b2) / (a1 - a2);
|
||||
//Find intersecting y coordinate.
|
||||
double y0 = x0 * a1 + b1;
|
||||
|
||||
//Add this to shrunk boundary list.
|
||||
GPSCoordinate coordinate = new GPSCoordinate(y0, x0);
|
||||
shrunkBoundary.add(coordinate);
|
||||
|
||||
|
||||
|
||||
return shrunkBoundary;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Determines if a list of coordinates describes a boundary polygon in clockwise or anti-clockwise order.
|
||||
* @param boundary The list of coordinates.
|
||||
* @return True if clockwise, false if anti-clockwise.
|
||||
*/
|
||||
public static boolean isClockwisePolygon(List<GPSCoordinate> boundary) {
|
||||
|
||||
/* From https://stackoverflow.com/questions/1165647/how-to-determine-if-a-list-of-polygon-points-are-in-clockwise-order
|
||||
sum all pairs (x2 − x1)(y2 + y1)
|
||||
point[0] = (5,0) edge[0]: (6-5)(4+0) = 4
|
||||
point[1] = (6,4) edge[1]: (4-6)(5+4) = -18
|
||||
point[2] = (4,5) edge[2]: (1-4)(5+5) = -30
|
||||
point[3] = (1,5) edge[3]: (1-1)(0+5) = 0
|
||||
point[4] = (1,0) edge[4]: (5-1)(0+0) = 0
|
||||
---
|
||||
-44 counter-clockwise
|
||||
*/
|
||||
|
||||
double sum = 0;
|
||||
|
||||
//For the first (size-1) adjacent pairs.
|
||||
for (int i = 0; i < (boundary.size() - 1); i++) {
|
||||
|
||||
//Get the points.
|
||||
GPSCoordinate firstPoint = boundary.get(i);
|
||||
GPSCoordinate secondPoint = boundary.get(i + 1);
|
||||
|
||||
double xDelta = secondPoint.getLongitude() - firstPoint.getLongitude();
|
||||
double ySum = secondPoint.getLatitude() + firstPoint.getLatitude();
|
||||
|
||||
double product = xDelta * ySum;
|
||||
|
||||
sum += product;
|
||||
|
||||
}
|
||||
|
||||
//For the final adjacent pair, between the last and first point.
|
||||
//Get the points.
|
||||
GPSCoordinate firstPoint = boundary.get(boundary.size() - 1);
|
||||
GPSCoordinate secondPoint = boundary.get(0);
|
||||
|
||||
double xDelta = secondPoint.getLongitude() - firstPoint.getLongitude();
|
||||
double ySum = secondPoint.getLatitude() + firstPoint.getLatitude();
|
||||
|
||||
double product = xDelta * ySum;
|
||||
|
||||
sum += product;
|
||||
|
||||
|
||||
//sum > 0 is clockwise, sum < 0 is anticlockwise.
|
||||
return sum > 0;
|
||||
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -1,128 +0,0 @@
|
||||
package seng302.Model;
|
||||
|
||||
|
||||
/**
|
||||
* Leg of the race, this is what each part of the race is divided into, from mark to mark.
|
||||
*/
|
||||
public class Leg {
|
||||
|
||||
/**
|
||||
* The name of the leg.
|
||||
*/
|
||||
private String name;
|
||||
|
||||
/**
|
||||
* The distance of the leg, in nautical miles.
|
||||
*/
|
||||
private double distanceNauticalMiles;
|
||||
|
||||
/**
|
||||
* The starting marker of the leg.
|
||||
*/
|
||||
private CompoundMark startCompoundMark;
|
||||
|
||||
/**
|
||||
* The ending marking of the leg.
|
||||
*/
|
||||
private CompoundMark endCompoundMark;
|
||||
|
||||
/**
|
||||
* The leg number within a race.
|
||||
*/
|
||||
private int legNumber;
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Constructs a leg from a name, start marker, end marker, and leg number.
|
||||
*
|
||||
* @param name Name of the Leg.
|
||||
* @param start Starting marker of the leg.
|
||||
* @param end Ending marker of the leg.
|
||||
* @param number Leg's position within the race.
|
||||
*/
|
||||
public Leg(String name, CompoundMark start, CompoundMark end, int number) {
|
||||
this.name = name;
|
||||
this.startCompoundMark = start;
|
||||
this.endCompoundMark = end;
|
||||
this.legNumber = number;
|
||||
this.calculateLegDistance();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Constructs a leg from a name and leg number.
|
||||
* This is currently used for constructing "dummy" DNF and Finish legs.
|
||||
*
|
||||
* @param name Name of the leg.
|
||||
* @param number Leg's position within the race.
|
||||
*/
|
||||
public Leg(String name, int number) {
|
||||
this.name = name;
|
||||
this.legNumber = number;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the name of the Leg.
|
||||
* @return The name of the Leg.
|
||||
*/
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the distance in nautical miles.
|
||||
* @return The total distance of the leg.
|
||||
*/
|
||||
public double getDistanceNauticalMiles() {
|
||||
return distanceNauticalMiles;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the leg number of the leg within a race.
|
||||
* @return The leg number of the leg within a race
|
||||
*/
|
||||
public int getLegNumber() {
|
||||
return legNumber;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the starting marker of the leg.
|
||||
* @return The starting marker of the leg.
|
||||
*/
|
||||
public CompoundMark getStartCompoundMark() {
|
||||
return startCompoundMark;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the ending marker of the leg.
|
||||
* @return The ending marker of the leg.
|
||||
*/
|
||||
public CompoundMark getEndCompoundMark() {
|
||||
return endCompoundMark;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the distance of the leg, in nautical miles.
|
||||
*/
|
||||
public void calculateLegDistance() {
|
||||
|
||||
//Gets the start and end coordinates.
|
||||
GPSCoordinate startMarker = this.startCompoundMark.getAverageGPSCoordinate();
|
||||
GPSCoordinate endMarker = this.endCompoundMark.getAverageGPSCoordinate();
|
||||
|
||||
//Calculates the distance between markers.
|
||||
double distanceNauticalMiles = GPSCoordinate.calculateDistanceNauticalMiles(startMarker, endMarker);
|
||||
|
||||
this.distanceNauticalMiles = distanceNauticalMiles;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -1,64 +0,0 @@
|
||||
package seng302.Model;
|
||||
|
||||
/**
|
||||
* Represents an individual mark.
|
||||
* Has a source ID, name, and position.
|
||||
*/
|
||||
public class Mark {
|
||||
|
||||
/**
|
||||
* The source ID of the mark.
|
||||
*/
|
||||
private int sourceID;
|
||||
|
||||
/**
|
||||
* The name of the mark.
|
||||
*/
|
||||
private String name;
|
||||
|
||||
/**
|
||||
* The position of the mark.
|
||||
*/
|
||||
private GPSCoordinate position;
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Constructs a mark with a given source ID, name, and position.
|
||||
* @param sourceID The source ID of the mark.
|
||||
* @param name The name of the mark.
|
||||
* @param position The position of the mark.
|
||||
*/
|
||||
public Mark(int sourceID, String name, GPSCoordinate position) {
|
||||
this.sourceID = sourceID;
|
||||
this.name = name;
|
||||
this.position = position;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the name of the mark.
|
||||
* @return The name of the mark.
|
||||
*/
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the source ID of the mark.
|
||||
* @return The source ID of the mark.
|
||||
*/
|
||||
public int getSourceID() {
|
||||
return sourceID;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the position of the mark.
|
||||
* @return The position of the mark.
|
||||
*/
|
||||
public GPSCoordinate getPosition() {
|
||||
return position;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -1,428 +0,0 @@
|
||||
package seng302.Model;
|
||||
|
||||
import javafx.util.Pair;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* Encapsulates an entire polar table. Has a function to calculate VMG.
|
||||
*/
|
||||
public class Polars {
|
||||
|
||||
/**
|
||||
* Internal store of data. Maps {@literal Pair<windSpeed, windAngle>} to boatSpeed.
|
||||
*/
|
||||
private Map<Pair<Double, Bearing>, Double> polarValues = new HashMap<>();
|
||||
|
||||
|
||||
/**
|
||||
* Stores a list of angles from the polar table - this is used during the calculateVMG function.
|
||||
* Maps between windSpeed and a list of angles for that wind speed.
|
||||
*/
|
||||
private HashMap<Double, List<Bearing>> polarAngles = new HashMap<>();
|
||||
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Ctor.
|
||||
*/
|
||||
public 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 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, Bearing relativeWindAngle, double boatSpeed) {
|
||||
|
||||
//We also add the same values with a complementary angle (e.g., angle = 50, complement = 360 - 50 = 310). This is because the data file contains angles [0, 180), but we need [0, 360).
|
||||
|
||||
//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<Double, Bearing> newKeyPositive = new Pair<>(trueWindSpeed, relativeWindAngle);
|
||||
this.polarValues.put(newKeyPositive, boatSpeed);
|
||||
|
||||
//Get the "negative" bearing - that is, the equivalent bearing between [180, 360).
|
||||
Bearing negativeBearing = Bearing.fromDegrees(360d - relativeWindAngle.degrees());
|
||||
|
||||
|
||||
//Ensure that the positive and negative angles aren't the same (e.g., pos = 0, neg = 360 - 0 = 0.
|
||||
if (!negativeBearing.equals(relativeWindAngle)) {
|
||||
Pair<Double, Bearing> newKeyNegative = new Pair<>(trueWindSpeed, negativeBearing);
|
||||
this.polarValues.put(newKeyNegative, boatSpeed);
|
||||
}
|
||||
|
||||
|
||||
//Add angle to angle list. Don't add if it already contains them.
|
||||
if (!this.polarAngles.get(trueWindSpeed).contains(relativeWindAngle)) {
|
||||
this.polarAngles.get(trueWindSpeed).add(relativeWindAngle);
|
||||
}
|
||||
|
||||
if (!this.polarAngles.get(trueWindSpeed).contains(negativeBearing)) {
|
||||
this.polarAngles.get(trueWindSpeed).add(negativeBearing);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* 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.
|
||||
* <br>
|
||||
* If you don't care about bearing bounds, simply pass in lower = 0, upper = 359.9.
|
||||
* <br>
|
||||
* Passing in lower = 0, upper = 0, or lower = 0, upper = 360 will both be treated the same as lower = 0, upper = 359.99999.
|
||||
* <br><br>
|
||||
* The resulting angle of the VMG will be within the interval [bearingLowerBound, bearingUpperBound].
|
||||
* <br><br>
|
||||
* If the lower bound is greater than the upper bound (e.g., lower = 70, upper = 55), then it checks that {@literal VMGAngle >= lower OR VMGAngle <= upper} (e.g., {@literal [70, 55] means angle >= 70, OR angle =< 55}).
|
||||
* <br><br>
|
||||
* Returns a VMG with 0 speed and 0 bearing if there are no VMGs with {@literal velocity > 0} in the acceptable bearing bounds.
|
||||
* @param trueWindAngle The current true wind angle.
|
||||
* @param trueWindSpeed The current true wind speed. Knots.
|
||||
* @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 The VMG.
|
||||
*/
|
||||
public VMG calculateVMG(Bearing trueWindAngle, double trueWindSpeed, Bearing destinationAngle, Bearing bearingLowerBound, Bearing bearingUpperBound) {
|
||||
|
||||
//Sorts polar angles.
|
||||
for (List<Bearing> angles : this.polarAngles.values()) {
|
||||
angles.sort(null);
|
||||
}
|
||||
|
||||
|
||||
//If the user enters [0, 360] for their bounds, there won't be any accepted angles, as Bearing(360) turn into Bearing(0) (it has the interval [0, 360)).
|
||||
//So if both bearing bounds are zero, we assume that the user wanted [0, 360) for the interval.
|
||||
//So, we give them Bearing(359.99999) as the upper bound.
|
||||
if ((bearingLowerBound.degrees() == 0d) && (bearingUpperBound.degrees() == 0d)) {
|
||||
bearingUpperBound = Bearing.fromDegrees(359.99999d);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//If the lower bound is greater than the upper bound, we have a "flipped" interval. That is for, e.g., [70, 55] the lower bound is greater than the upper bound, and so it checks that (VMGAngle >= 70 OR VMGAngle =< 55), instead of (VMGAngle >= 70 AND VMGAngle =< 55).
|
||||
boolean flippedInterval = Polars.isFlippedInterval(bearingLowerBound, bearingUpperBound);
|
||||
|
||||
|
||||
|
||||
//We need to find the upper and lower wind speeds from the Polars table, for a given current wind speed (e.g., current wind speed is 11kn, therefore lower = 8kn, upper = 12kn).
|
||||
double polarWindSpeedLowerBound = 0d;
|
||||
double polarWindSpeedUpperBound = 9999999d;//Start this off with a value larger than any in the Polars table so that it actually works.
|
||||
//This indicates whether or not we've managed to find a wind speed larger than the current wind speed (the upper bound) in the Polars table (in cases where the current wind speed is larger than any in the file we will never find an upper bound).
|
||||
boolean foundUpperBoundWindSpeed = false;
|
||||
boolean foundLowerBoundWindSpeed = false;
|
||||
for (Pair<Double, Bearing> key : this.polarValues.keySet()) {
|
||||
|
||||
//The key is Pair<windSpeed, windAngle>, so pair.key is windSpeed.
|
||||
double currentPolarSpeed = key.getKey();
|
||||
|
||||
//Lower bound.
|
||||
if ((currentPolarSpeed >= polarWindSpeedLowerBound) && (currentPolarSpeed <= trueWindSpeed)) {
|
||||
polarWindSpeedLowerBound = currentPolarSpeed;
|
||||
foundLowerBoundWindSpeed = true;
|
||||
}
|
||||
|
||||
//Upper bound.
|
||||
if ((currentPolarSpeed < polarWindSpeedUpperBound) && (currentPolarSpeed > trueWindSpeed)) {
|
||||
polarWindSpeedUpperBound = currentPolarSpeed;
|
||||
foundUpperBoundWindSpeed = true;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
//Find the angle with the best VMG.
|
||||
//We need to find the VMGs for both lower and upper bound wind speeds, and interpolate between them.
|
||||
List<VMG> vmgs = new ArrayList<>();
|
||||
|
||||
//Put wind speed bounds we found above into a list.
|
||||
List<Double> windSpeedBounds = new ArrayList<>(2);
|
||||
|
||||
if (foundLowerBoundWindSpeed) {
|
||||
windSpeedBounds.add(polarWindSpeedLowerBound);
|
||||
}
|
||||
if (foundUpperBoundWindSpeed) {
|
||||
windSpeedBounds.add(polarWindSpeedUpperBound);
|
||||
}
|
||||
|
||||
|
||||
//Calculate VMG for any wind speed bounds we found.
|
||||
for (double polarWindSpeed : windSpeedBounds) {
|
||||
|
||||
//The list of polar angles for this wind speed.
|
||||
List<Bearing> polarAngles = this.polarAngles.get(polarWindSpeed);
|
||||
|
||||
|
||||
double bestVMGVelocity = 0;
|
||||
double bestVMGSpeed = 0;
|
||||
Bearing bestVMGAngle = Bearing.fromDegrees(0d);
|
||||
|
||||
//Calculate the VMG for all possible angles at this wind speed.
|
||||
for (double angleDegree = 0; angleDegree < 360; angleDegree += 1) {
|
||||
Bearing angle = Bearing.fromDegrees(angleDegree);
|
||||
|
||||
//This is the true bearing of the boat, if it went at the angle against the wind.
|
||||
//For angle < 90 OR angle > 270, it means that the boat is going into the wind (tacking).
|
||||
//For angle > 90 AND angle < 270, it means that the boat is actually going with the wind (gybing).
|
||||
double trueBoatBearingDegrees = trueWindAngle.degrees() + angle.degrees() + 180d;
|
||||
Bearing trueBoatBearing = Bearing.fromDegrees(trueBoatBearingDegrees);
|
||||
|
||||
|
||||
//Check that the boat's bearing would actually be acceptable.
|
||||
//We continue (skip to next iteration) if it is outside of the interval.
|
||||
if (!Polars.isBearingInsideInterval(trueBoatBearing, bearingLowerBound, bearingUpperBound)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
//Basic linear interpolation. Find the nearest two angles from the table, and interpolate between them.
|
||||
|
||||
//Check which pair of adjacent angles the angle is between.
|
||||
boolean foundAdjacentAngles = false;
|
||||
Bearing lowerBound = Bearing.fromDegrees(0d);
|
||||
Bearing upperBound = Bearing.fromDegrees(0d);
|
||||
for (int i = 0; i < polarAngles.size() - 1; i++) {
|
||||
Bearing currentAngle = polarAngles.get(i);
|
||||
Bearing nextAngle = polarAngles.get(i + 1);
|
||||
//Check that angle is in interval [lower, upper).
|
||||
if ((angle.degrees() >= currentAngle.degrees()) && (angle.degrees() < nextAngle.degrees())) {
|
||||
foundAdjacentAngles = true;
|
||||
lowerBound = currentAngle;
|
||||
upperBound = nextAngle;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!foundAdjacentAngles) {
|
||||
//If we never found the interval, then it must be the "last" interval, between the i'th and 0'th values - angles are periodic, so they wrap around.
|
||||
lowerBound = polarAngles.get(polarAngles.size() - 1);
|
||||
upperBound = polarAngles.get(0);
|
||||
}
|
||||
|
||||
|
||||
//Calculate how far between those points the angle is.
|
||||
|
||||
|
||||
//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 = calculatePeriodicLinearInterpolateScalar(lowerBound.degrees(), upperBound.degrees(), 360, angle.degrees());
|
||||
|
||||
//Get the estimated boat speeds for the lower and upper angles.
|
||||
Pair<Double, Bearing> lowerKey = new Pair<>(polarWindSpeed, lowerBound);
|
||||
Pair<Double, Bearing> upperKey = new Pair<>(polarWindSpeed, upperBound);
|
||||
double lowerSpeed = this.polarValues.get(lowerKey);
|
||||
double upperSpeed = this.polarValues.get(upperKey);
|
||||
|
||||
//Calculate the speed at the interpolated angle.
|
||||
double interpolatedSpeed = calculateLinearInterpolation(lowerSpeed, upperSpeed, interpolationScalar);
|
||||
|
||||
|
||||
//This is the delta angle between the boat's true bearing and the destination.
|
||||
double angleBetweenDestAndTackDegrees = trueBoatBearing.degrees() - destinationAngle.degrees();
|
||||
Bearing angleBetweenDestAndTack = Bearing.fromDegrees(angleBetweenDestAndTackDegrees);
|
||||
|
||||
//This is the estimated velocity towards the target (e.g., angling away from the target reduces velocity).
|
||||
double interpolatedVelocity = Math.cos(angleBetweenDestAndTack.radians()) * interpolatedSpeed;
|
||||
|
||||
|
||||
//Check that the velocity is better, if so, update our best VMG so far, for this wind speed.
|
||||
if (interpolatedVelocity > bestVMGVelocity) {
|
||||
bestVMGVelocity = interpolatedVelocity;
|
||||
bestVMGSpeed = interpolatedSpeed;
|
||||
bestVMGAngle = trueBoatBearing;
|
||||
}
|
||||
|
||||
}
|
||||
//Angle iteration loop is finished.
|
||||
|
||||
//Create the VMG, and add to list.
|
||||
VMG vmg = new VMG(bestVMGSpeed, bestVMGAngle);
|
||||
vmgs.add(vmg);
|
||||
|
||||
}
|
||||
|
||||
|
||||
//If we never found an upper bound for the wind speed, we will only have one VMG (for the lower bound), so we can't interpolate/extrapolate anything.
|
||||
if (!foundUpperBoundWindSpeed) {
|
||||
return vmgs.get(0);
|
||||
} else {
|
||||
//We may have more than one VMG. If we found an upper and lower bound we will have two, if we only found an upper bound (e.g., wind speed = 2kn, upper = 4kn, lower = n/a) we will only have one VMG, but must interpolate between that and a new VMG with 0kn speed.
|
||||
|
||||
//We do a simple linear interpolation.
|
||||
|
||||
VMG vmg1 = vmgs.get(0);
|
||||
VMG vmg2;
|
||||
if (vmgs.size() > 1) {
|
||||
//If we have a second VMG use it.
|
||||
vmg2 = vmgs.get(1);
|
||||
} else {
|
||||
//Otherwise create a VMG with zero speed, but the same angle. This is what our VMG would be with 0 knot wind speed (boats don't move at 0 knots).
|
||||
//We also need to swap them around, as vmg1 needs to be the vmg for the lower bound wind speed, and vmg2 is the upper bound wind speed.
|
||||
vmg2 = vmg1;
|
||||
vmg1 = new VMG(0, vmg1.getBearing());
|
||||
}
|
||||
|
||||
|
||||
//Get the interpolation scalar for the current wind speed.
|
||||
double interpolationScalar = calculateLinearInterpolateScalar(polarWindSpeedLowerBound, polarWindSpeedUpperBound, trueWindSpeed);
|
||||
|
||||
//We then calculate the interpolated VMG speed and angle using the interpolation scalar.
|
||||
double interpolatedSpeed = calculateLinearInterpolation(vmg1.getSpeed(), vmg2.getSpeed(), interpolationScalar);
|
||||
double interpolatedAngleDegrees = calculateLinearInterpolation(vmg1.getBearing().degrees(), vmg2.getBearing().degrees(), interpolationScalar);
|
||||
|
||||
Bearing interpolatedAngle = Bearing.fromDegrees(interpolatedAngleDegrees);
|
||||
|
||||
|
||||
//Return the interpolated VMG.
|
||||
return new VMG(interpolatedSpeed, interpolatedAngle);
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Determines whether an interval is "flipped". This means that the lower bound is greater than the upper bound (e.g., [290, 43] degrees).
|
||||
* @param lowerBound The lower bound.
|
||||
* @param upperBound The upper bound.
|
||||
* @return True if the interval is flipped, false otherwise.
|
||||
*/
|
||||
public static boolean isFlippedInterval(Bearing lowerBound, Bearing upperBound) {
|
||||
|
||||
//If the lower bound is greater than the upper bound, we have a "flipped" interval.
|
||||
boolean flippedInterval = false;
|
||||
if (lowerBound.degrees() > upperBound.degrees()) {
|
||||
flippedInterval = true;
|
||||
}
|
||||
|
||||
return flippedInterval;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Determines if a bearing is inside an interval.
|
||||
* @param bearing The bearing to check.
|
||||
* @param lowerBound The lower bound of the interval.
|
||||
* @param upperBound The upper bound of the interval.
|
||||
* @return True if the bearing is inside the interval, false otherwise.
|
||||
*/
|
||||
public static boolean isBearingInsideInterval(Bearing bearing, Bearing lowerBound, Bearing upperBound) {
|
||||
|
||||
//Check if it's a flipped interval.
|
||||
boolean flippedInterval = Polars.isFlippedInterval(lowerBound, upperBound);
|
||||
|
||||
if (flippedInterval) {
|
||||
//Bearing must be inside [lower, upper], where lower > upper. So, bearing must be >= lower, or bearing < upper. We use inverted logic since we are skipping if it is true.
|
||||
if ((bearing.degrees() >= lowerBound.degrees()) || (bearing.degrees() <= upperBound.degrees())) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
|
||||
} else {
|
||||
//Bearing must be inside [lower, upper].
|
||||
if ((bearing.degrees() >= lowerBound.degrees()) && (bearing.degrees() <= upperBound.degrees())) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Calculate the linear interpolation scalar for a value between two bounds. E.g., lower = 7, upper = 10, value = 8, therefore the scalar (or the proportion between the bounds) is 0.333.
|
||||
* Also assumes that the bounds are periodic - e.g., for angles a lower bound of 350deg and upper bound of 5deg is in interval of 15 degrees.
|
||||
* @param lowerBound The lower bound to interpolate between.
|
||||
* @param upperBound The upper bound to interpolate between.
|
||||
* @param value The value that sits between the lower and upper bounds.
|
||||
* @param period The period of the bounds (e.g., for angles, they have a period of 360 degrees).
|
||||
* @return The interpolation scalar for the value between two bounds.
|
||||
*/
|
||||
public static double calculatePeriodicLinearInterpolateScalar(double lowerBound, double upperBound, double period, double value) {
|
||||
|
||||
//This is the "distance" between the value and its lower bound.
|
||||
//I.e., L----V-----------U
|
||||
// <----> is lowerDelta.
|
||||
double lowerDelta = value - lowerBound;
|
||||
|
||||
//This is the "distance" between the upper and lower bound.
|
||||
//I.e., L----V-----------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.
|
||||
while (intervalDelta < 0) {
|
||||
intervalDelta += period;
|
||||
}
|
||||
|
||||
//This is how far between the lower and upper bounds the value is, as a proportion (e.g., 0.5 = half-way, 0.9 = close to upper).
|
||||
double interpolationScalar = lowerDelta / intervalDelta;
|
||||
|
||||
return interpolationScalar;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate the linear interpolation scalar for a value between two bounds. E.g., lower = 7, upper = 10, value = 8, therefore the scalar (or the proportion between the bounds) is 0.333.
|
||||
* Assumes that the upper bound is larger than the lower bound.
|
||||
* @param lowerBound The lower bound to interpolate between.
|
||||
* @param upperBound The upper bound to interpolate between.
|
||||
* @param value The value that sits between the lower and upper bounds.
|
||||
* @return The interpolation scalar for the value between two bounds.
|
||||
*/
|
||||
public static double calculateLinearInterpolateScalar(double lowerBound, double upperBound, double value) {
|
||||
|
||||
//This is the "distance" between the value and its lower bound.
|
||||
//I.e., L----V-----------U
|
||||
// <----> is lowerDelta.
|
||||
double lowerDelta = value - lowerBound;
|
||||
|
||||
//This is the "distance" between the upper and lower bound.
|
||||
//I.e., L----V-----------U
|
||||
// <----------------> is intervalDelta.
|
||||
double intervalDelta = upperBound - lowerBound;
|
||||
|
||||
//This is how far between the lower and upper bounds the value is, as a proportion (e.g., 0.5 = half-way, 0.9 = close to upper).
|
||||
double interpolationScalar = lowerDelta / intervalDelta;
|
||||
|
||||
return interpolationScalar;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Does a linear interpolation between two bounds, using an interpolation scalar - i.e., value = lower + (scalar * delta).
|
||||
* @param lowerBound Lower bound to interpolate from.
|
||||
* @param upperBound Upper bound to interpolate to.
|
||||
* @param interpolationScalar Interpolation scalar - the proportion the target value sits between the two bounds.
|
||||
* @return The interpolated value.
|
||||
*/
|
||||
public static double calculateLinearInterpolation(double lowerBound, double upperBound, double interpolationScalar) {
|
||||
|
||||
//Get the delta between upper and lower bounds.
|
||||
double boundDelta = upperBound - lowerBound;
|
||||
|
||||
//Calculate the speed at the interpolated angle.
|
||||
double interpolatedValue = lowerBound + (boundDelta * interpolationScalar);
|
||||
|
||||
return interpolatedValue;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,929 +0,0 @@
|
||||
package seng302.Model;
|
||||
|
||||
import javafx.animation.AnimationTimer;
|
||||
import javafx.collections.FXCollections;
|
||||
import javafx.collections.ObservableList;
|
||||
import seng302.Constants;
|
||||
import seng302.DataInput.RaceDataSource;
|
||||
import seng302.MockOutput;
|
||||
import seng302.Networking.Messages.BoatStatus;
|
||||
import seng302.Networking.Messages.Enums.BoatStatusEnum;
|
||||
import seng302.Networking.Messages.Enums.RaceStatusEnum;
|
||||
import seng302.Networking.Messages.Enums.RaceTypeEnum;
|
||||
import seng302.Networking.Messages.RaceStatus;
|
||||
import seng302.Networking.Utils.AC35UnitConverter;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
|
||||
import static java.lang.Math.cos;
|
||||
|
||||
|
||||
/**
|
||||
* Represents a yacht race.
|
||||
* Has a course, boats, boundaries, etc...
|
||||
* Is responsible for simulating the race, and sending messages to a MockOutput instance.
|
||||
*/
|
||||
public class Race implements Runnable {
|
||||
|
||||
/**
|
||||
* An observable list of boats in the race.
|
||||
*/
|
||||
private ObservableList<Boat> boats;
|
||||
|
||||
/**
|
||||
* An observable list of compound marks in the race.
|
||||
*/
|
||||
private ObservableList<CompoundMark> compoundMarks;
|
||||
|
||||
/**
|
||||
* A list of legs in the race.
|
||||
*/
|
||||
private List<Leg> legs;
|
||||
|
||||
/**
|
||||
* A list of coordinates describing the boundary of the course.
|
||||
*/
|
||||
private List<GPSCoordinate> boundary;
|
||||
|
||||
/**
|
||||
* A copy of the boundary list, except "shrunk" inwards by 50m.
|
||||
*/
|
||||
private List<GPSCoordinate> shrinkBoundary;
|
||||
|
||||
/**
|
||||
* The elapsed time, in milliseconds, of the race.
|
||||
*/
|
||||
private long totalTimeElapsed;
|
||||
|
||||
/**
|
||||
* The starting timestamp, in milliseconds, of the race.
|
||||
*/
|
||||
private long startTime;
|
||||
|
||||
/**
|
||||
* The scale factor of the race.
|
||||
* Frame periods are multiplied by this to get the amount of time a single frame represents.
|
||||
* E.g., frame period = 20ms, scale = 5, frame represents 20 * 5 = 100ms, and so boats are simulated for 100ms, even though only 20ms actually occurred.
|
||||
*/
|
||||
private int scaleFactor = 5;
|
||||
|
||||
/**
|
||||
* The race ID of the course.
|
||||
*/
|
||||
private int raceId;
|
||||
|
||||
/**
|
||||
* The current status of the race.
|
||||
*/
|
||||
private RaceStatusEnum raceStatusEnum;
|
||||
|
||||
/**
|
||||
* The type of race this is.
|
||||
*/
|
||||
private RaceTypeEnum raceType;
|
||||
|
||||
/**
|
||||
* The percent chance that a boat fails the race, and enters a DNF state, at each checkpoint.
|
||||
* 0 = 0%, 100 = 100%.
|
||||
*/
|
||||
private int dnfChance = 0;
|
||||
|
||||
|
||||
/**
|
||||
* The mockOutput to send messages to.
|
||||
*/
|
||||
private MockOutput mockOutput;
|
||||
|
||||
|
||||
/**
|
||||
* Wind direction bearing.
|
||||
*/
|
||||
private Bearing windDirection;
|
||||
|
||||
/**
|
||||
* Wind speed (knots).
|
||||
* Convert this to millimeters per second before passing to RaceStatus.
|
||||
*/
|
||||
private double windSpeed;
|
||||
|
||||
private double windDirDegrees;
|
||||
private double windDir;
|
||||
private int changeWind = 4;
|
||||
private static final int windUpperBound = 235;
|
||||
private static final int windLowerBound = 215;
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Constructs a race object with a given RaceDataSource and sends events to the given mockOutput.
|
||||
* @param raceData Data source for race related data (boats, legs, etc...).
|
||||
* @param mockOutput The mockOutput to send events to.
|
||||
*/
|
||||
public Race(RaceDataSource raceData, MockOutput mockOutput) {
|
||||
|
||||
this.mockOutput = mockOutput;
|
||||
|
||||
this.boats = FXCollections.observableArrayList(raceData.getBoats());
|
||||
this.compoundMarks = FXCollections.observableArrayList(raceData.getCompoundMarks());
|
||||
this.boundary = raceData.getBoundary();
|
||||
this.shrinkBoundary = GPSCoordinate.getShrinkBoundary(this.boundary);
|
||||
|
||||
|
||||
this.legs = raceData.getLegs();
|
||||
this.legs.add(new Leg("Finish", this.legs.size()));
|
||||
|
||||
this.raceId = raceData.getRaceId();
|
||||
|
||||
//The start time is current time + 4 minutes, scaled. prestart is 3 minutes, and we add another.
|
||||
this.startTime = System.currentTimeMillis() + ((Constants.RacePreStartTime + (1 * 60 * 1000)) / this.scaleFactor);
|
||||
|
||||
this.setRaceStatusEnum(RaceStatusEnum.NOT_ACTIVE);
|
||||
this.raceType = RaceTypeEnum.FLEET_RACE;
|
||||
|
||||
this.windSpeed = 12;
|
||||
this.windDirection = Bearing.fromDegrees(180);
|
||||
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Runnable for the thread.
|
||||
*/
|
||||
public void run() {
|
||||
initialiseBoats();
|
||||
initialiseWindDir();
|
||||
countdownTimer.start();
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse the compound marker boats through mock output.
|
||||
*/
|
||||
private void parseMarks() {
|
||||
for (CompoundMark compoundMark : this.compoundMarks) {
|
||||
|
||||
//Get the individual marks from the compound mark.
|
||||
Mark mark1 = compoundMark.getMark1();
|
||||
Mark mark2 = compoundMark.getMark2();
|
||||
|
||||
//If they aren't null, parse them (some compound marks only have one mark).
|
||||
if (mark1 != null) {
|
||||
this.parseIndividualMark(mark1);
|
||||
}
|
||||
|
||||
if (mark2 != null) {
|
||||
this.parseIndividualMark(mark2);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses an individual marker boat, and sends it to mockOutput.
|
||||
* @param mark The marker boat to parse.
|
||||
*/
|
||||
private void parseIndividualMark(Mark mark) {
|
||||
|
||||
this.mockOutput.parseBoatLocation(mark.getSourceID(), mark.getPosition().getLatitude(), mark.getPosition().getLongitude(),0,0, totalTimeElapsed+startTime);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse the boats in the race, and send it to mockOutput.
|
||||
*/
|
||||
private void parseBoatLocations() {
|
||||
|
||||
//Parse each boat.
|
||||
for (Boat boat : this.boats) {
|
||||
|
||||
this.parseIndividualBoatLocation(boat);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses an individual boat, and sends it to mockOutput.
|
||||
* @param boat The boat to parse.
|
||||
*/
|
||||
private void parseIndividualBoatLocation(Boat boat) {
|
||||
|
||||
this.mockOutput.parseBoatLocation(
|
||||
boat.getSourceID(),
|
||||
boat.getCurrentPosition().getLatitude(),
|
||||
boat.getCurrentPosition().getLongitude(),
|
||||
boat.getBearing().degrees(),
|
||||
boat.getCurrentSpeed(),
|
||||
startTime + totalTimeElapsed
|
||||
);
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Updates the race status enumeration based on the current time, in milliseconds.
|
||||
* @param currentTime The current time, in milliseconds.
|
||||
*/
|
||||
private void updateRaceStatusEnum(long currentTime) {
|
||||
|
||||
//The amount of milliseconds until the race starts.
|
||||
long timeToStart = this.startTime - currentTime;
|
||||
|
||||
//Scale the time to start based on the scale factor.
|
||||
long timeToStartScaled = timeToStart / this.scaleFactor;
|
||||
|
||||
|
||||
if (timeToStartScaled > Constants.RacePreStartTime) {
|
||||
//Time > 3 minutes is the prestart period.
|
||||
this.setRaceStatusEnum(RaceStatusEnum.PRESTART);
|
||||
|
||||
} else if ((timeToStartScaled <= Constants.RacePreStartTime) && (timeToStartScaled >= Constants.RacePreparatoryTime)) {
|
||||
//Time between [1, 3] minutes is the warning period.
|
||||
this.setRaceStatusEnum(RaceStatusEnum.WARNING);
|
||||
|
||||
} else if ((timeToStartScaled <= Constants.RacePreparatoryTime) && (timeToStartScaled > 0)) {
|
||||
//Time between (0, 1] minutes is the preparatory period.
|
||||
this.setRaceStatusEnum(RaceStatusEnum.PREPARATORY);
|
||||
|
||||
} else {
|
||||
//Otherwise, the race has started!
|
||||
this.setRaceStatusEnum(RaceStatusEnum.STARTED);
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses the race status, and sends it to mockOutput.
|
||||
*/
|
||||
private void parseRaceStatus() {
|
||||
|
||||
//A race status message contains a list of boat statuses.
|
||||
List<BoatStatus> boatStatuses = new ArrayList<>();
|
||||
|
||||
//Add each boat status to the status list.
|
||||
for (Boat boat : boats) {
|
||||
|
||||
BoatStatus boatStatus = new BoatStatus(boat.getSourceID(), boat.getStatus(), boat.getCurrentLeg().getLegNumber(), boat.getEstimatedTime());
|
||||
|
||||
boatStatuses.add(boatStatus);
|
||||
}
|
||||
|
||||
//TODO REFACTOR for consistency, could send parameters to mockOutput instead of the whole racestatus. This will also fix the sequence number issue.
|
||||
|
||||
//Convert wind direction and speed to ints. //TODO this conversion should be done inside the racestatus class.
|
||||
int windDirectionInt = AC35UnitConverter.encodeHeading(this.windDirection.degrees());
|
||||
int windSpeedInt = (int) (windSpeed * Constants.KnotsToMMPerSecond);
|
||||
|
||||
//Create race status object, and send it.
|
||||
RaceStatus raceStatus = new RaceStatus(System.currentTimeMillis(), this.raceId, this.getRaceStatusEnum().getValue(), this.startTime, windDirectionInt, windSpeedInt, this.getRaceType().getValue(), boatStatuses);
|
||||
|
||||
mockOutput.parseRaceStatus(raceStatus);
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the status of all boats in the race to RACING.
|
||||
*/
|
||||
private void setBoatsStatusToRacing() {
|
||||
|
||||
for (Boat boat : this.boats) {
|
||||
boat.setStatus(BoatStatusEnum.RACING);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Countdown timer until race starts.
|
||||
*/
|
||||
protected AnimationTimer countdownTimer = new AnimationTimer() {
|
||||
|
||||
|
||||
long currentTime = System.currentTimeMillis();
|
||||
|
||||
@Override
|
||||
public void handle(long arg0) {
|
||||
|
||||
//Update the race status based on the current time.
|
||||
updateRaceStatusEnum(this.currentTime);
|
||||
|
||||
//Parse the boat locations.
|
||||
parseBoatLocations();
|
||||
|
||||
//Parse the marks.
|
||||
parseMarks();
|
||||
|
||||
// Change wind direction
|
||||
changeWindDir();
|
||||
|
||||
//Parse the race status.
|
||||
parseRaceStatus();
|
||||
|
||||
|
||||
if (getRaceStatusEnum() == RaceStatusEnum.STARTED) {
|
||||
System.setProperty("javafx.animation.fullspeed", "true");
|
||||
setBoatsStatusToRacing();
|
||||
raceTimer.start();
|
||||
this.stop();
|
||||
}
|
||||
|
||||
//Update the animations timer's time.
|
||||
currentTime = System.currentTimeMillis();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Timer that runs for the duration of the race, until all boats finish.
|
||||
*/
|
||||
private AnimationTimer raceTimer = new AnimationTimer() {
|
||||
|
||||
/**
|
||||
* Start time of loop, in milliseconds.
|
||||
*/
|
||||
long timeRaceStarted = System.currentTimeMillis();
|
||||
|
||||
/**
|
||||
* The time of the previous frame, in milliseconds.
|
||||
*/
|
||||
long lastFrameTime = timeRaceStarted;
|
||||
|
||||
@Override
|
||||
public void handle(long arg0) {
|
||||
|
||||
//Get the current time.
|
||||
long currentTime = System.currentTimeMillis();
|
||||
|
||||
//Update the total elapsed time.
|
||||
totalTimeElapsed = currentTime - this.timeRaceStarted;
|
||||
|
||||
//As long as there is at least one boat racing, we still simulate the race.
|
||||
if (getNumberOfActiveBoats() != 0) {
|
||||
|
||||
//Get the time period of this frame.
|
||||
long framePeriod = currentTime - lastFrameTime;
|
||||
//We actually simulate 20ms istead of the amount of time that has occurred, as that ensure that we don't end up with large frame periods on slow computers, causing position issues.
|
||||
framePeriod = 20;
|
||||
|
||||
|
||||
//For each boat, we update its position, and generate a BoatLocationMessage.
|
||||
for (Boat boat : boats) {
|
||||
|
||||
//If it is still racing, update its position.
|
||||
if (boat.getStatus() == BoatStatusEnum.RACING) {
|
||||
|
||||
updatePosition(boat, framePeriod, totalTimeElapsed);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
} else {
|
||||
//Otherwise, the race is over!
|
||||
raceFinished.start();
|
||||
setRaceStatusEnum(RaceStatusEnum.FINISHED);
|
||||
this.stop();
|
||||
}
|
||||
|
||||
if (getNumberOfActiveBoats() != 0) {
|
||||
// Change wind direction
|
||||
changeWindDir();
|
||||
|
||||
//Parse the boat locations.
|
||||
parseBoatLocations();
|
||||
|
||||
//Parse the marks.
|
||||
parseMarks();
|
||||
|
||||
//Parse the race status.
|
||||
parseRaceStatus();
|
||||
|
||||
|
||||
//Update the last frame time.
|
||||
this.lastFrameTime = currentTime;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Broadcast that the race has finished.
|
||||
*/
|
||||
protected AnimationTimer raceFinished = new AnimationTimer(){
|
||||
int iters = 0;
|
||||
@Override
|
||||
public void handle(long now) {
|
||||
RaceStatus raceStatus = new RaceStatus(System.currentTimeMillis(), raceId, 4, startTime, 0, 2300, 2, new ArrayList<>());
|
||||
mockOutput.parseRaceStatus(raceStatus);
|
||||
if (iters > 500){
|
||||
mockOutput.stop();
|
||||
stop();
|
||||
}
|
||||
iters++;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Initialise the boats in the race.
|
||||
* This sets their starting positions and current legs.
|
||||
*/
|
||||
public void initialiseBoats() {
|
||||
|
||||
//Gets the starting positions of the boats.
|
||||
List<GPSCoordinate> startingPositions = getSpreadStartingPositions();
|
||||
|
||||
//Get iterators for our boat and position lists.
|
||||
Iterator<Boat> boatIt = this.boats.iterator();
|
||||
Iterator<GPSCoordinate> startPositionIt = startingPositions.iterator();
|
||||
|
||||
//Iterate over the pair of lists.
|
||||
while (boatIt.hasNext() && startPositionIt.hasNext()) {
|
||||
|
||||
//Get the next boat and position.
|
||||
Boat boat = boatIt.next();
|
||||
GPSCoordinate startPosition = startPositionIt.next();
|
||||
|
||||
|
||||
//The boat starts on the first leg of the race.
|
||||
boat.setCurrentLeg(this.legs.get(0));
|
||||
|
||||
//Boats start with 0 knots speed.
|
||||
boat.setCurrentSpeed(0d);
|
||||
|
||||
//Place the boat at its starting position.
|
||||
boat.setCurrentPosition(startPosition);
|
||||
|
||||
//Boats start facing their next marker.
|
||||
boat.setBearing(boat.calculateBearingToNextMarker());
|
||||
|
||||
//Sets the boats status to prestart - it changes to racing when the race starts.
|
||||
boat.setStatus(BoatStatusEnum.PRESTART);
|
||||
|
||||
//We set a large time since tack change so that it calculates a new VMG when the simulation starts.
|
||||
boat.setTimeSinceTackChange(999999);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Creates a list of starting positions for the different boats, so they do not appear cramped at the start line.
|
||||
*
|
||||
* @return A list of starting positions.
|
||||
*/
|
||||
public List<GPSCoordinate> getSpreadStartingPositions() {
|
||||
|
||||
//The first compound marker of the race - the starting gate.
|
||||
CompoundMark compoundMark = this.legs.get(0).getStartCompoundMark();
|
||||
|
||||
//The position of the two markers from the compound marker.
|
||||
GPSCoordinate mark1Position = compoundMark.getMark1Position();
|
||||
GPSCoordinate mark2Position = compoundMark.getMark2Position();
|
||||
|
||||
|
||||
//Calculates the azimuth between the two points.
|
||||
Azimuth azimuth = GPSCoordinate.calculateAzimuth(mark1Position, mark2Position);
|
||||
|
||||
//Calculates the distance between the two points.
|
||||
double distanceMeters = GPSCoordinate.calculateDistanceMeters(mark1Position, mark2Position);
|
||||
|
||||
//The number of boats in the race.
|
||||
int numberOfBoats = this.boats.size();
|
||||
|
||||
//Calculates the distance between each boat. We divide by numberOfBoats + 1 to ensure that no boat is placed on one of the starting gate's marks.
|
||||
double distanceBetweenBoatsMeters = distanceMeters / (numberOfBoats + 1);
|
||||
|
||||
|
||||
//List to store coordinates in.
|
||||
List<GPSCoordinate> positions = new ArrayList<>();
|
||||
|
||||
//We start spacing boats out from mark 1.
|
||||
GPSCoordinate position = mark1Position;
|
||||
|
||||
//For each boat, displace position, and store it.
|
||||
for (int i = 0; i < numberOfBoats; i++) {
|
||||
|
||||
position = GPSCoordinate.calculateNewPosition(position, distanceBetweenBoatsMeters, azimuth);
|
||||
|
||||
positions.add(position);
|
||||
|
||||
}
|
||||
|
||||
return positions;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Calculates a boat's VMG.
|
||||
* @param boat The boat to calculate VMG for.
|
||||
* @param bearingBounds An array containing the lower and upper acceptable bearing bounds to keep the boat in the course.
|
||||
* @return VMG for the specified boat.
|
||||
*/
|
||||
private VMG calculateVMG(Boat boat, Bearing[] bearingBounds) {
|
||||
|
||||
//Get the lower and upper acceptable bounds.
|
||||
Bearing lowerAcceptableBound = bearingBounds[0];
|
||||
Bearing upperAcceptableBound = bearingBounds[1];
|
||||
|
||||
|
||||
//Find the VMG inside these bounds.
|
||||
VMG bestVMG = boat.getPolars().calculateVMG(this.windDirection, this.windSpeed, boat.calculateBearingToNextMarker(), lowerAcceptableBound, upperAcceptableBound);
|
||||
|
||||
|
||||
|
||||
return bestVMG;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Determines whether or not a given VMG improves the velocity of a boat, if it were currently using currentVMG.
|
||||
* @param currentVMG The current VMG of the boat.
|
||||
* @param potentialVMG The new VMG to test.
|
||||
* @param bearingToDestination The bearing between the boat and its destination.
|
||||
* @return True if the new VMG is improves velocity, false otherwise.
|
||||
*/
|
||||
private boolean improvesVelocity(VMG currentVMG, VMG potentialVMG, Bearing bearingToDestination) {
|
||||
|
||||
//Calculates the angle between the boat and its destination.
|
||||
Angle angleBetweenDestAndHeading = Angle.fromDegrees(currentVMG.getBearing().degrees() - bearingToDestination.degrees());
|
||||
|
||||
//Calculates the angle between the new VMG and the boat's destination.
|
||||
Angle angleBetweenDestAndNewVMG = Angle.fromDegrees(potentialVMG.getBearing().degrees() - bearingToDestination.degrees());
|
||||
|
||||
|
||||
//Calculate the boat's current velocity.
|
||||
double currentVelocity = Math.cos(angleBetweenDestAndHeading.radians()) * currentVMG.getSpeed();
|
||||
|
||||
//Calculate the potential velocity with the new VMG.
|
||||
double vmgVelocity = Math.cos(angleBetweenDestAndNewVMG.radians()) * potentialVMG.getSpeed();
|
||||
|
||||
//Return whether or not the new VMG gives better velocity.
|
||||
return vmgVelocity > currentVelocity;
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines whether or not a given VMG improves the velocity of a boat.
|
||||
* @param boat The boat to test.
|
||||
* @param vmg The new VMG to test.
|
||||
* @return True if the new VMG is improves velocity, false otherwise.
|
||||
*/
|
||||
private boolean improvesVelocity(Boat boat, VMG vmg) {
|
||||
|
||||
//Get the boats "current" VMG.
|
||||
VMG boatVMG = new VMG(boat.getCurrentSpeed(), boat.getBearing());
|
||||
|
||||
//Check if the new VMG is better than the boat's current VMG.
|
||||
return this.improvesVelocity(boatVMG, vmg, boat.calculateBearingToNextMarker());
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the distance a boat has travelled and updates its current position according to this value.
|
||||
*
|
||||
* @param boat The boat to be updated.
|
||||
* @param updatePeriodMilliseconds The time, in milliseconds, since the last update.
|
||||
* @param totalElapsedMilliseconds The total number of milliseconds that have elapsed since the start of the race.
|
||||
*/
|
||||
protected void updatePosition(Boat boat, long updatePeriodMilliseconds, long totalElapsedMilliseconds) {
|
||||
|
||||
//Checks if the current boat has finished the race or not.
|
||||
boolean finish = this.isLastLeg(boat.getCurrentLeg());
|
||||
|
||||
if (!finish) {
|
||||
|
||||
|
||||
//Calculates the distance travelled, in meters, in the current timeslice.
|
||||
double distanceTravelledMeters = boat.calculateMetersTravelled(updatePeriodMilliseconds);
|
||||
|
||||
//Scale it.
|
||||
distanceTravelledMeters = distanceTravelledMeters * this.scaleFactor;
|
||||
|
||||
|
||||
//Move the boat forwards that many meters, and advances its time counters by enough milliseconds.
|
||||
boat.moveForwards(distanceTravelledMeters, updatePeriodMilliseconds * this.scaleFactor);
|
||||
|
||||
|
||||
//Only get a new VMG if the boat will go outside the course, or X seconds have elapsed.
|
||||
boolean willStayInsideCourse = this.checkBearingInsideCourse(boat.getBearing(), boat.getCurrentPosition());
|
||||
long tackPeriod = 15000;
|
||||
if (!willStayInsideCourse || (boat.getTimeSinceTackChange() > tackPeriod)) {
|
||||
|
||||
//Calculate the boat's bearing bounds, to ensure that it doesn't go out of the course.
|
||||
Bearing[] bearingBounds = this.calculateBearingBounds(boat);
|
||||
|
||||
|
||||
//Calculate the new VMG.
|
||||
VMG newVMG = this.calculateVMG(boat, bearingBounds);
|
||||
|
||||
|
||||
//If the new vmg improves velocity, use it.
|
||||
if (improvesVelocity(boat, newVMG)) {
|
||||
boat.setVMG(newVMG);
|
||||
|
||||
} else {
|
||||
//We also need to use the new VMG if our current bearing will take us out of the course.
|
||||
if (!willStayInsideCourse) {
|
||||
boat.setVMG(newVMG);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this.updateEstimatedTime(boat);
|
||||
|
||||
|
||||
//Check the boats position (update leg and stuff).
|
||||
this.checkPosition(boat, totalTimeElapsed);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the upper and lower bounds that the boat may have in order to not go outside of the course.
|
||||
* @param boat The boat to check.
|
||||
* @return An array of bearings. The first is the lower bound, the second is the upper bound.
|
||||
*/
|
||||
private Bearing[] calculateBearingBounds(Boat boat) {
|
||||
|
||||
Bearing[] bearings = new Bearing[2];
|
||||
|
||||
Bearing lowerBearing = Bearing.fromDegrees(0.001);
|
||||
Bearing upperBearing = Bearing.fromDegrees(359.999);
|
||||
|
||||
|
||||
|
||||
double lastAngle = -1;
|
||||
boolean lastAngleWasGood = false;
|
||||
|
||||
//Check all bearings between [0, 360).
|
||||
for (double angle = 0; angle < 360; angle += 1) {
|
||||
|
||||
//Create bearing from angle.
|
||||
Bearing bearing = Bearing.fromDegrees(angle);
|
||||
|
||||
//Check that if it is acceptable.
|
||||
boolean bearingIsGood = this.checkBearingInsideCourse(bearing, boat.getCurrentPosition());
|
||||
|
||||
|
||||
if (lastAngle != -1) {
|
||||
|
||||
if (lastAngleWasGood && !bearingIsGood) {
|
||||
//We have flipped over from good bearings to bad bearings. So the last good bearing is the upper bearing.
|
||||
upperBearing = Bearing.fromDegrees(lastAngle);
|
||||
}
|
||||
|
||||
if (!lastAngleWasGood && bearingIsGood) {
|
||||
//We have flipped over from bad bearings to good bearings. So the current bearing is the lower bearing.
|
||||
lowerBearing = Bearing.fromDegrees(angle);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
lastAngle = angle;
|
||||
lastAngleWasGood = bearingIsGood;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
//TODO BUG if it can't find either upper or lower, it returns (0, 359.999). Should return (boatbearing, boatbearing+0.0001)
|
||||
bearings[0] = lowerBearing;
|
||||
bearings[1] = upperBearing;
|
||||
|
||||
return bearings;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Checks if a given bearing, starting at a given position, would put a boat out of the course boundaries.
|
||||
* @param bearing The bearing to check.
|
||||
* @param position The position to start from.
|
||||
* @return True if the bearing would keep the boat in the course, false if it would take it out of the course.
|
||||
*/
|
||||
private boolean checkBearingInsideCourse(Bearing bearing, GPSCoordinate position) {
|
||||
|
||||
//Get azimuth from bearing.
|
||||
Azimuth azimuth = Azimuth.fromBearing(bearing);
|
||||
|
||||
|
||||
//Tests to see if a point in front of the boat is out of bounds.
|
||||
double epsilonMeters = 50d;
|
||||
GPSCoordinate testCoord = GPSCoordinate.calculateNewPosition(position, epsilonMeters, azimuth);
|
||||
|
||||
//If it isn't inside the boundary, calculate new bearing.
|
||||
if (GPSCoordinate.isInsideBoundary(testCoord, this.shrinkBoundary)) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Checks if a boat has finished any legs, or has pulled out of race (DNF).
|
||||
* @param boat The boat to check.
|
||||
* @param timeElapsed The total time, in milliseconds, that has elapsed since the race started.
|
||||
*/
|
||||
protected void checkPosition(Boat boat, long timeElapsed) {
|
||||
|
||||
//The distance, in nautical miles, within which the boat needs to get in order to consider that it has reached the marker.
|
||||
double epsilonNauticalMiles = 100.0 / Constants.NMToMetersConversion; //100 meters. TODO should be more like 5-10.
|
||||
|
||||
if (boat.calculateDistanceToNextMarker() < epsilonNauticalMiles) {
|
||||
//Boat has reached its target marker, and has moved on to a new leg.
|
||||
|
||||
|
||||
|
||||
//Calculate how much the boat overshot the marker by.
|
||||
double overshootMeters = boat.calculateDistanceToNextMarker();
|
||||
|
||||
|
||||
//Move boat on to next leg.
|
||||
Leg nextLeg = this.legs.get(boat.getCurrentLeg().getLegNumber() + 1);
|
||||
boat.setCurrentLeg(nextLeg);
|
||||
|
||||
//Add overshoot distance into the distance travelled for the next leg.
|
||||
boat.setDistanceTravelledInLeg(overshootMeters);
|
||||
|
||||
//Setting a high value for this allows the boat to immediately do a large turn, as it needs to in order to get to the next mark.
|
||||
boat.setTimeSinceTackChange(999999);
|
||||
|
||||
|
||||
//Check if the boat has finished or stopped racing.
|
||||
|
||||
if (this.isLastLeg(boat.getCurrentLeg())) {
|
||||
//Boat has finished.
|
||||
boat.setTimeFinished(timeElapsed);
|
||||
boat.setCurrentSpeed(0);
|
||||
boat.setStatus(BoatStatusEnum.FINISHED);
|
||||
} else if (doNotFinish()) {
|
||||
//Boat has pulled out of race.
|
||||
boat.setTimeFinished(timeElapsed);
|
||||
boat.setCurrentLeg(new Leg("DNF", -1));
|
||||
boat.setCurrentSpeed(0);
|
||||
boat.setStatus(BoatStatusEnum.DNF);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Determines whether or not a specific leg is the last leg in the race.
|
||||
* @param leg The leg to check.
|
||||
* @return Returns true if it is the last, false otherwse.
|
||||
*/
|
||||
private boolean isLastLeg(Leg leg) {
|
||||
|
||||
//Get the last leg.
|
||||
Leg lastLeg = this.legs.get(this.legs.size() - 1);
|
||||
|
||||
//Check its ID.
|
||||
int lastLegID = lastLeg.getLegNumber();
|
||||
|
||||
//Get the specified leg's ID.
|
||||
int legID = leg.getLegNumber();
|
||||
|
||||
|
||||
//Check if they are the same.
|
||||
return legID == lastLegID;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the chance each boat has of failing at a gate or marker
|
||||
*
|
||||
* @param chance percentage chance a boat has of failing per checkpoint.
|
||||
*/
|
||||
protected void setDnfChance(int chance) {
|
||||
if (chance >= 0 && chance <= 100) {
|
||||
dnfChance = chance;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Decides if a boat should received a DNF status.
|
||||
* @return True means it should DNF, false means it shouldn't.
|
||||
*/
|
||||
protected boolean doNotFinish() {
|
||||
Random rand = new Random();
|
||||
return rand.nextInt(100) < dnfChance;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the current race status.
|
||||
* @return The current race status.
|
||||
*/
|
||||
public RaceStatusEnum getRaceStatusEnum() {
|
||||
return raceStatusEnum;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the current race status.
|
||||
* @param raceStatusEnum The new status of the race.
|
||||
*/
|
||||
private void setRaceStatusEnum(RaceStatusEnum raceStatusEnum) {
|
||||
this.raceStatusEnum = raceStatusEnum;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the type of race this is.
|
||||
* @return The type of race this is.
|
||||
*/
|
||||
public RaceTypeEnum getRaceType() {
|
||||
return raceType;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the number of boats that are still active in the race.
|
||||
* They become inactive by either finishing or withdrawing.
|
||||
* @return The number of boats still active in the race.
|
||||
*/
|
||||
protected int getNumberOfActiveBoats() {
|
||||
|
||||
int numberofActiveBoats = 0;
|
||||
|
||||
for (Boat boat : this.boats) {
|
||||
|
||||
//If the boat is currently racing, count it.
|
||||
if (boat.getStatus() == BoatStatusEnum.RACING) {
|
||||
numberofActiveBoats++;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return numberofActiveBoats;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns an observable list of boats in the race.
|
||||
* @return List of boats in the race.
|
||||
*/
|
||||
public ObservableList<Boat> getBoats() {
|
||||
return boats;
|
||||
}
|
||||
|
||||
protected void initialiseWindDir(){
|
||||
windDirDegrees = 225;
|
||||
windDir = AC35UnitConverter.convertHeading(windDirDegrees);
|
||||
/*windDir = new Random().nextInt(65535+1);
|
||||
windDir = BoatLocation.convertHeadingIntToDouble(255);*/
|
||||
this.windDirection = new Bearing((int)windDir);
|
||||
}
|
||||
|
||||
protected void changeWindDir(){
|
||||
int r = new Random().nextInt(changeWind)+1;
|
||||
if(r==1){
|
||||
windDirDegrees = (0.5 + windDirDegrees) % 360;
|
||||
} else if (r==2){
|
||||
windDirDegrees = ((windDirDegrees - 0.5) + 360) % 360;///keep the degrees positive when below 0
|
||||
}
|
||||
if (windDirDegrees > windUpperBound){
|
||||
windDirDegrees = windUpperBound;
|
||||
}
|
||||
if (windDirDegrees < windLowerBound){
|
||||
windDirDegrees = windLowerBound;
|
||||
}
|
||||
|
||||
windDir = AC35UnitConverter.convertHeading(windDirDegrees);
|
||||
this.windDirection = new Bearing(windDirDegrees);
|
||||
}
|
||||
|
||||
protected void setChangeWind(int changeVal){
|
||||
if (changeVal>=0){
|
||||
changeWind = changeVal;
|
||||
}
|
||||
}
|
||||
|
||||
protected int getWind(){
|
||||
return (int)windDir;
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the boat's estimated time to next mark if positive
|
||||
* @param boat to estimate time given its velocity
|
||||
*/
|
||||
private void updateEstimatedTime(Boat boat) {
|
||||
double velocityToMark = boat.getCurrentSpeed() * cos(boat.getBearing().radians() - boat.calculateBearingToNextMarker().radians()) / Constants.KnotsToMMPerSecond;
|
||||
if (velocityToMark > 0) {
|
||||
long timeFromNow = (long)(1000*boat.calculateDistanceToNextMarker()/velocityToMark);
|
||||
boat.setEstimatedTime(startTime + totalTimeElapsed + timeFromNow);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
package seng302.Model;
|
||||
|
||||
/**
|
||||
* This class encapsulates VMG - that is, velocity made good. It has a speed component and a bearing component.
|
||||
*/
|
||||
public class VMG {
|
||||
|
||||
/**
|
||||
* Speed component of the VMG, in knots.
|
||||
*/
|
||||
private double speed;
|
||||
|
||||
/**
|
||||
* Bearing component of the VMG.
|
||||
*/
|
||||
private Bearing bearing;
|
||||
|
||||
|
||||
/**
|
||||
* Ctor. Creates a VMG object with a given speed and bearing (that is, a velocity).
|
||||
* @param speed Speed component of the VMG.
|
||||
* @param bearing Bearing component of the VMG.
|
||||
*/
|
||||
public VMG(double speed, Bearing bearing) {
|
||||
this.speed = speed;
|
||||
this.bearing = bearing;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the speed component of this VMG object, measured in knots.
|
||||
* @return Speed component of this VMG object.
|
||||
*/
|
||||
public double getSpeed() {
|
||||
return speed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the bearing component of this VMG object.
|
||||
* @return Bearing component of this VMG object.
|
||||
*/
|
||||
public Bearing getBearing() {
|
||||
return bearing;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,55 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
|
||||
<BoatConfig>
|
||||
<Boats>
|
||||
|
||||
<!--Mark Boats-->
|
||||
<Boat Type="Mark" BoatName="PRO" SourceID="101" >
|
||||
<GPSposition X= "-64.854304" Y="32.296577" Z="0"/>
|
||||
</Boat>
|
||||
<Boat Type="Mark" BoatName="PIN" SourceID="102" >
|
||||
<GPSposition X= "-64.855242" Y="32.293771" Z="0"/>
|
||||
</Boat>
|
||||
<Boat Type="Mark" BoatName="Marker1" SourceID="103" >
|
||||
<GPSposition X= "-64.843983" Y="32.293039" Z="0"/>
|
||||
</Boat>
|
||||
<Boat Type="Mark" BoatName="WGL" SourceID="104" >
|
||||
<GPSposition X= "-64.850045" Y="32.28468" Z="0"/>
|
||||
</Boat>
|
||||
<Boat Type="Mark" BoatName="WGR" SourceID="105" >
|
||||
<GPSposition X= "-64.847591" Y="32.280164" Z="0"/>
|
||||
</Boat>
|
||||
<Boat Type="Mark" BoatName="LGL" SourceID="106" >
|
||||
<GPSposition X= "-64.835249" Y="32.309693" Z="0"/>
|
||||
</Boat>
|
||||
<Boat Type="Mark" BoatName="LGR" SourceID="107" >
|
||||
<GPSposition X= "-64.831785" Y="32.308046" Z="0"/>
|
||||
</Boat>
|
||||
<Boat Type="Mark" BoatName="FL" SourceID="108" >
|
||||
<GPSposition X= "-64.839291" Y="32.317379" Z="0"/>
|
||||
</Boat>
|
||||
<Boat Type="Mark" BoatName="FR" SourceID="109" >
|
||||
<GPSposition X= "-64.83626" Y="32.317257" Z="0"/>
|
||||
</Boat>
|
||||
|
||||
<!--Participants-->
|
||||
<Boat BoatName="Team ORACLE USA" HullNum="RG01" ShapeID="0" ShortName="USA" SourceID="121" StoweName="USA" Type="Yacht">
|
||||
<GPSposition X="-64.854304" Y="32.296577" Z="0"/>
|
||||
</Boat>
|
||||
<Boat BoatName="Land Rover BAR" HullNum="RG01" ShapeID="0" ShortName="GBR" SourceID="122" StoweName="GBR" Type="Yacht">
|
||||
<GPSposition X="-64.854304" Y="32.296577" Z="0"/>
|
||||
</Boat>
|
||||
<Boat BoatName="SoftBank Team Japan" HullNum="RG01" ShapeID="0" ShortName="JPN" SourceID="123" StoweName="JPN" Type="Yacht">
|
||||
<GPSposition X="-64.854304" Y="32.296577" Z="0"/>
|
||||
</Boat>
|
||||
<Boat BoatName="Groupama Team France" HullNum="RG01" ShapeID="0" ShortName="FRA" SourceID="124" StoweName="FRA" Type="Yacht">
|
||||
<GPSposition X="-64.854304" Y="32.296577" Z="0"/>
|
||||
</Boat>
|
||||
<Boat BoatName="Artemis Racing" HullNum="RG01" ShapeID="0" ShortName="SWE" SourceID="125" StoweName="SWE" Type="Yacht">
|
||||
<GPSposition X="-64.854304" Y="32.296577" Z="0"/>
|
||||
</Boat>
|
||||
<Boat BoatName="Emirates Team New Zealand" HullNum="RG01" ShapeID="0" ShortName="NZL" SourceID="126" StoweName="NZL" Type="Yacht">
|
||||
<GPSposition X="-64.854304" Y="32.296577" Z="0"/>
|
||||
</Boat>
|
||||
</Boats>
|
||||
</BoatConfig>
|
||||
@@ -1,57 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<Race>
|
||||
<RaceID>5326</RaceID>
|
||||
<RaceType>FLEET</RaceType>
|
||||
<CreationTimeDate>CREATION_TIME</CreationTimeDate>
|
||||
<RaceStartTime Postpone="false" Time="START_TIME"/>
|
||||
<Participants>
|
||||
<Yacht SourceID="121"/>
|
||||
<Yacht SourceID="122"/>
|
||||
<Yacht SourceID="123"/>
|
||||
<Yacht SourceID="124"/>
|
||||
<Yacht SourceID="125"/>
|
||||
<Yacht SourceID="126"/>
|
||||
</Participants>
|
||||
<CompoundMarkSequence>
|
||||
<Corner CompoundMarkID="1" SeqID="1"/>
|
||||
<Corner CompoundMarkID="2" SeqID="2"/>
|
||||
<Corner CompoundMarkID="4" SeqID="3"/>
|
||||
<Corner CompoundMarkID="3" SeqID="4"/>
|
||||
<Corner CompoundMarkID="4" SeqID="5"/>
|
||||
<Corner CompoundMarkID="5" SeqID="6"/>
|
||||
</CompoundMarkSequence>
|
||||
<Course>
|
||||
<CompoundMark CompoundMarkID="1" Name="Start Line">
|
||||
<Mark SeqId="1" Name="PRO" TargetLat="32.296577" TargetLng="-64.854304" SourceID="101"/>
|
||||
<Mark SeqId="2" Name="PIN" TargetLat="32.293771" TargetLng="-64.855242" SourceID="102"/>
|
||||
</CompoundMark>
|
||||
<CompoundMark CompoundMarkID="2" Name="Marker 1">
|
||||
<Mark Name="Marker1" TargetLat="32.293039" TargetLng="-64.843983" SourceID="103"/>
|
||||
</CompoundMark>
|
||||
<CompoundMark CompoundMarkID="3" Name="Windward Gate">
|
||||
<Mark Name="WGL" SeqId="1" TargetLat="32.28468" TargetLng="-64.850045" SourceID="104"/>
|
||||
<Mark Name="WGR" SeqId="2" TargetLat="32.280164" TargetLng="-64.847591" SourceID="105"/>
|
||||
</CompoundMark>
|
||||
<CompoundMark CompoundMarkID="4" Name="Leeward Gate">
|
||||
<Mark Name="LGL" SeqId="1" TargetLat="32.309693" TargetLng="-64.835249" SourceID="106"/>
|
||||
<Mark Name="LGR" SeqId="2" TargetLat="32.308046" TargetLng="-64.831785" SourceID="107"/>
|
||||
</CompoundMark>
|
||||
<CompoundMark CompoundMarkID="5" Name="Finish Line">
|
||||
<Mark Name="FL" SeqId="1" TargetLat="32.317379" TargetLng="-64.839291" SourceID="108"/>
|
||||
<Mark Name="FR" SeqId="2" TargetLat="32.317257" TargetLng="-64.83626" SourceID="109"/>
|
||||
</CompoundMark>
|
||||
</Course>
|
||||
<CourseLimit>
|
||||
<Limit Lat="32.313922" Lon="-64.837168" SeqID="1"/>
|
||||
<Limit Lat="32.317379" Lon="-64.839291" SeqID="2"/>
|
||||
<Limit Lat="32.317911" Lon="-64.836996" SeqID="3"/>
|
||||
<Limit Lat="32.317257" Lon="-64.83626" SeqID="4"/>
|
||||
<Limit Lat="32.304273" Lon="-64.822834" SeqID="5"/>
|
||||
<Limit Lat="32.279097" Lon="-64.841545" SeqID="6"/>
|
||||
<Limit Lat="32.279604" Lon="-64.849871" SeqID="7"/>
|
||||
<Limit Lat="32.289545" Lon="-64.854162" SeqID="8"/>
|
||||
<Limit Lat="32.290198" Lon="-64.858711" SeqID="9"/>
|
||||
<Limit Lat="32.297164" Lon="-64.856394" SeqID="10"/>
|
||||
<Limit Lat="32.296148" Lon="-64.849184" SeqID="11"/>
|
||||
</CourseLimit>
|
||||
</Race>
|
||||
@@ -1,10 +0,0 @@
|
||||
<RegattaConfig>
|
||||
<RegattaID>3</RegattaID>
|
||||
<RegattaName>New Zealand Test</RegattaName>
|
||||
<CourseName>North Head</CourseName>
|
||||
<CentralLatitude>-36.82791529</CentralLatitude>
|
||||
<CentralLongitude>174.81218919</CentralLongitude>
|
||||
<CentralAltitude>0.00</CentralAltitude>
|
||||
<UtcOffset>12</UtcOffset>
|
||||
<MagneticVariation>14.1</MagneticVariation>
|
||||
</RegattaConfig>
|
||||
@@ -1,8 +0,0 @@
|
||||
Tws,Twa0,Bsp0,Twa1,Bsp1,UpTwa,UpBsp,Twa2,Bsp2,Twa3,Bsp3,Twa4,Bsp4,Twa5,Bsp5,Twa6,Bsp6,DnTwa,DnBsp,Twa7,Bsp7
|
||||
4,0,0,30,4,45,8,60,9,75,10,90,10,115,10,145,10,155,10,175,4
|
||||
8,0,0,30,7,43,10,60,11,75,11,90,11,115,12,145,12,153,12,175,10
|
||||
12,0,0,30,11,43,14.4,60,16,75,20,90,23,115,24,145,23,153,21.6,175,14
|
||||
16,0,0,30,12,42,19.2,60,25,75,27,90,31,115,32,145,30,153,28.8,175,20
|
||||
20,0,0,30,13,41,24,60,29,75,37,90,39,115,40,145,38,153,36,175,24
|
||||
25,0,0,30,15,40,30,60,38,75,44,90,49,115,50,145,49,151,47,175,30
|
||||
30,0,0,30,15,42,30,60,37,75,42,90,48,115,49,145,48,150,46,175,32
|
||||
|
Reference in New Issue
Block a user