eine sinnvolle Route aus ausgewählten GPX- Tracks

[Jouta]

Hallo zusammen,
ich muss für meine Projektarbeit eine Anwendung entwickeln, die anhand des Knoten-Kanten-Modells prüfen soll, ob sich die ausgewählten Abschnitte tatsächlich zu einer Tour kombinieren lassen. (Haben zwei jeweils aufeinanderfolgende Segmente einen gemeinsamen Endpunkt?). Außerdem soll die Anwendung ermitteln, ob es sich um eine Rundroute handelt. In diesem Fall müssen der Anfangs- und Endpunkt des erzeugten GPX-Tracks identisch sein.
Ich habe einen Code geschrieben, der nur prüft, ob zwei Segmente(Abschnitte) zusammen verbunden sind, aber sich nicht zu einer sinnvollen Tour kombinieren lassen, jemand eine Idee? Lieben Dank für eure Hilfe. Hier ist der Code:

public class Matrix {
	private boolean[][] matrix;

	public Matrix() {

		// [KANTEN][KKNOTEN]
		matrix = new boolean[24][19];

		for (int i = 0; i < matrix.length; i++) {
			for (int j = 0; j < matrix[i].length; j++) {
				matrix[i][j] = false;
			}
		}
		matrix[1][0] = true;
		matrix[1][1] = true;

		matrix[2][0] = true;
		matrix[2][2] = true;

		matrix[3][1] = true;
		matrix[3][2] = true;

		matrix[4][1] = true;
		matrix[4][14] = true;

		matrix[5][0] = true;
		matrix[5][3] = true;

		matrix[6][3] = true;
		matrix[6][4] = true;

		matrix[7][2] = true;
		matrix[7][4] = true;

		matrix[8][3] = true;
		matrix[8][5] = true;

		matrix[9][4] = true;
		matrix[9][5] = true;

		matrix[10][5] = true;
		matrix[10][6] = true;

		matrix[11][5] = true;
		matrix[11][7] = true;

		matrix[12][6] = true;
		matrix[12][15] = true;

		matrix[13][6] = true;
		matrix[13][7] = true;

		matrix[14][7] = true;
		matrix[14][8] = true;

		matrix[15][8] = true;
		matrix[15][9] = true;

		matrix[16][9] = true;
		matrix[16][10] = true;

		matrix[17][9] = true;
		matrix[17][10] = true;

		matrix[18][10] = true;
		matrix[18][11] = true;

		matrix[19][11] = true;
		matrix[19][16] = true;

		matrix[20][11] = true;
		matrix[20][17] = true;

		matrix[21][11] = true;
		matrix[21][12] = true;

		matrix[22][12] = true;
		matrix[22][18] = true;

		matrix[23][8] = true;
		matrix[23][12] = true;
	}

	/**
	 * This function calculates a list of segments from a list of selected
	 * segments. The calculated segments can be used for bicycle navigation.
	 * 
	 * @param selectedSegments
	 * @return
	 */
	public LinkedList<Integer> getTrackFromSelectedSegments(LinkedList<Integer> selectedSegments) throws Exception {

		// check if segments are connected
		if (!checkIfSegmentsAreConnected(selectedSegments)) {
			throw new Exception("segments are not connected");
		}

		// sort segments
		LinkedList<Integer> result = createTrackFromSegments(selectedSegments);

		return result;
	}

	/**
	 * This functions checks whether the segments are connected.
	 * 
	 * @param segments
	 * @return
	 */
	private boolean checkIfSegmentsAreConnected(LinkedList<Integer> segments) {

		// do something
		for (int i = 0; i < segments.size() - 1; i++) {
			Integer segmentX = segments.get(i);
			boolean hasSegmentConnection = false;

			for (int j = i + 1; j < segments.size(); j++) {
				Integer segmentY = segments.get(j);

				if (checkIfSegmentsAreConnected(segmentX, segmentY)) {
					System.out.println("segment " + segmentX + " und "
							+ segmentY + " hängen zusammen.");
					hasSegmentConnection = true;
					break;
				}
			}

			if (!hasSegmentConnection) {
				System.out.println("segment " + segmentX
						+ " hat keine verbindung.");
				return false;
			}
		}

		return true;
	}

	private boolean checkIfSegmentsAreConnected(Integer segmentX,
			Integer segmentY) {

		System.out.println("Überprüfe segmente " + segmentX + " und "
				+ segmentY);

		int segmentXknoten1 = -1;
		int segmentXknoten2 = -1;

		for (int i = 0; i < matrix[segmentX].length; i++) {
			if (matrix[segmentX][i] == true) {
				if (segmentXknoten1 == -1) {
					segmentXknoten1 = i;
				} else {
					segmentXknoten2 = i;
				}
			}
		}
		System.out.println("segment " + segmentX + " hat knoten "
				+ segmentXknoten1 + " und " + segmentXknoten2);

		int segmentYknoten1 = -1;
		int segmentYknoten2 = -1;

		for (int i = 0; i < matrix[segmentY].length; i++) {
			if (matrix[segmentY][i] == true) {
				if (segmentYknoten1 == -1) {
					segmentYknoten1 = i;
				} else {
					segmentYknoten2 = i;
				}
			}
		}
		System.out.println("segment " + segmentY + " hat knoten "
				+ segmentYknoten1 + " und " + segmentYknoten2);

		if (segmentXknoten1 == segmentYknoten1
				|| segmentXknoten1 == segmentYknoten2
				|| segmentXknoten2 == segmentYknoten1
				|| segmentXknoten2 == segmentYknoten2) {
			return true;
		} else {
			return false;

		}

	}

	/**
	 * This function sorts the connected segments so that they are a track.
	 * 
	 * @param segments
	 * @return
	 */
	private LinkedList<Integer> createTrackFromSegments(
			LinkedList<Integer> segments) {

		LinkedList<Integer> result = new LinkedList<Integer>();

		// do something

		return result;
	}

	public boolean isConnected(int i, int j) {
		return matrix[i][j];
	}

	public boolean isConnected(LinkedList<Integer> ints) {
		if (ints == null || ints.size() < 2) {
			throw new IllegalArgumentException("List too small");
		}
		int first = ints.get(0);
		for (int i = 1; i < ints.size(); i++) {
			int second = ints.get(i);
			if (!isConnected(first, second)) {
				return false;
			}
			first = second;

		}
		return true;
	}
}




public class Main {

	public static void main(String[] args) {

		testWithSuccess();
		testWithFailure();
	}
	
	public static void testWithSuccess() {
		
		Matrix matrix = new Matrix();
		
		LinkedList<Integer> selectedSegments = new LinkedList<Integer>();
		selectedSegments.add(new Integer(3));
		selectedSegments.add(new Integer(1));
		selectedSegments.add(new Integer(5));
		
		try {
			System.out.println("TEST WITH SUCCESS");
			LinkedList<Integer> track = matrix.getTrackFromSelectedSegments(selectedSegments);
			for (Integer segment : track) {
				System.out.println("segment: " + segment.toString());
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public static void testWithFailure() {
		
		Matrix matrix = new Matrix();
		
		LinkedList<Integer> selectedSegments = new LinkedList<Integer>();
		selectedSegments.add(new Integer(11));
		selectedSegments.add(new Integer(1));
		selectedSegments.add(new Integer(5));
		
		try {
			System.out.println("TEST WITH FAILURE");
			LinkedList<Integer> track = matrix.getTrackFromSelectedSegments(selectedSegments);
			for (Integer segment : track) {
				System.out.println("segment: " + segment.toString());
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}