408 lines
16 KiB
Java
408 lines
16 KiB
Java
package graph;
|
|
|
|
import OurApplication.OurLogElement;
|
|
import logging.LogElementList;
|
|
import visualizationElements.Edge;
|
|
import visualizationElements.EdgeStyle;
|
|
import visualizationElements.Vertex;
|
|
|
|
import java.awt.*;
|
|
import java.util.HashMap;
|
|
import java.util.Objects;
|
|
import java.util.PriorityQueue;
|
|
import java.util.Vector;
|
|
|
|
public class UndirectedGraph<T extends VertexMarking, U extends EdgeMarking> extends Graph<T, U> {
|
|
|
|
// ATTRIBUTE
|
|
|
|
private visualizationElements.Graph screenGraph;
|
|
private LogElementList<OurLogElement> logList;
|
|
|
|
|
|
// KONSTRUKTOREN
|
|
|
|
public UndirectedGraph() {
|
|
super();
|
|
this.screenGraph = new visualizationElements.Graph(new Vector<Vertex>(), new Vector<Edge>(), false, EdgeStyle.Direct);
|
|
this.logList = new LogElementList<>();
|
|
}
|
|
|
|
|
|
public UndirectedGraph(String s) {
|
|
super(s);
|
|
this.screenGraph = new visualizationElements.Graph(new Vector<Vertex>(), new Vector<Edge>(), false, EdgeStyle.Direct);
|
|
this.logList = new LogElementList<>();
|
|
}
|
|
|
|
|
|
// GET-ER
|
|
|
|
public visualizationElements.Graph getScreenGraph() {
|
|
return this.screenGraph;
|
|
}
|
|
|
|
|
|
public LogElementList<OurLogElement> getLogList() {
|
|
return this.logList;
|
|
}
|
|
|
|
|
|
public visualizationElements.Graph getScreenGraphCopy() {
|
|
visualizationElements.Graph graphCopy = new visualizationElements.Graph(new Vector<Vertex>(), new Vector<Edge>(), false, EdgeStyle.Direct);
|
|
Vector<visualizationElements.Vertex> copiedVertexes = new Vector<>();
|
|
Vector<visualizationElements.Edge> copiedEdges = new Vector<>();
|
|
for (visualizationElements.Vertex vertexCopy : this.screenGraph.getVertexes()) {
|
|
visualizationElements.Vertex newCopiedVertex = new visualizationElements.Vertex(vertexCopy.getXpos(), vertexCopy.getYpos(), vertexCopy.getMarking(), vertexCopy.getColor());
|
|
copiedVertexes.add(newCopiedVertex);
|
|
graphCopy.setVertexes(copiedVertexes);
|
|
}
|
|
for (visualizationElements.Edge edgeCopy : this.screenGraph.getEdges()) {
|
|
visualizationElements.Edge newCopiedEdge = new visualizationElements.Edge(edgeCopy.getSource(), edgeCopy.getDestination(), edgeCopy.getMarking(), edgeCopy.getColor());
|
|
copiedEdges.add(newCopiedEdge);
|
|
graphCopy.setEdges(copiedEdges);
|
|
}
|
|
return graphCopy;
|
|
}
|
|
|
|
|
|
// HINZUFÜGEN
|
|
|
|
// Kante hinzufügen
|
|
public void addEdge(MarkedEdge<U> e) {
|
|
super.addEdge(e);
|
|
this.screenGraph.getEdges().add(e.getScreenEdge());
|
|
}
|
|
|
|
|
|
// Knoten hinzufügen
|
|
public void addVertex(MarkedVertex<T> n) {
|
|
super.addVertex(n);
|
|
this.screenGraph.getVertexes().add(n.getScreenVertex());
|
|
}
|
|
|
|
|
|
// LÖSCHEN
|
|
|
|
// Kante löschen
|
|
public void removeEdge(MarkedEdge<U> e) {
|
|
super.removeEdge(e);
|
|
this.screenGraph.getEdges().remove(e.getScreenEdge());
|
|
}
|
|
|
|
|
|
// Knoten löschen
|
|
public void removeVertex(MarkedVertex<T> n) {
|
|
super.removeVertex(n);
|
|
this.screenGraph.getVertexes().remove(n.getScreenVertex());
|
|
}
|
|
|
|
|
|
// KNOTEN EIGENSCHAFTEN
|
|
|
|
// Prüfung des Grades eines Knotens
|
|
public int degree(MarkedVertex<T> n) {
|
|
int degree = 0;
|
|
for (MarkedEdge<U> i: this.getAllEdges()) {
|
|
if (i.getSource() == n) {
|
|
degree += 1;
|
|
}
|
|
if (i.getDestination() == n) {
|
|
degree += 1;
|
|
}
|
|
}
|
|
return degree;
|
|
}
|
|
|
|
|
|
public int degree(String s) throws NameDoesNotExistException{
|
|
for (MarkedVertex<T> i: this.getAllVertexes()) {
|
|
if (Objects.equals(i.getName(), s)) {
|
|
return degree(i);
|
|
}
|
|
}
|
|
throw new NameDoesNotExistException("One of the Vertexes might not exist");
|
|
}
|
|
|
|
|
|
// Prüfung, welche Knoten Nachbarn sind
|
|
public Vector<MarkedVertex<T>> getNeighbours(MarkedVertex<T> n) {
|
|
Vector<MarkedVertex<T>> neighbours = new Vector<>();
|
|
for (MarkedEdge<U> i: this.getAllEdges()) {
|
|
if (i.getSource() == n && !neighbours.contains(i.getDestination())) {
|
|
neighbours.add((MarkedVertex<T>) i.getDestination());
|
|
} else if (i.getDestination() == n && !neighbours.contains(i.getSource())) {
|
|
neighbours.add((MarkedVertex<T>) i.getSource());
|
|
}
|
|
}
|
|
return neighbours;
|
|
}
|
|
|
|
|
|
public int getShortestPathDijkstra(MarkedVertex<T> n1, MarkedVertex<T> n2) {
|
|
|
|
// Erstellt Hashmap um Distanz von Startnoten zu jedem Knoten auf dem Graph zu tracken
|
|
// Erstellt Hashmap um zu tracken welche Knoten schon besucht wurden
|
|
// Erstelle Hashmap um Vorgängerknoten zu tracken
|
|
// Initialisierung aller Distanzen auf UNENDLICH (= -1)
|
|
// Initialisierung, dass kein Knoten besucht wurde
|
|
// Initialisierung aller Vorgänger auf null
|
|
HashMap<MarkedVertex<T>, Integer> distance = new HashMap<>();
|
|
HashMap<MarkedVertex<T>, Boolean> visited = new HashMap<>();
|
|
HashMap<MarkedVertex<T>, MarkedVertex<T>> predecessors = new HashMap<>();
|
|
for (MarkedVertex<T> i: this.getAllVertexes()) {
|
|
distance.put(i, -1);
|
|
visited.put(i, false);
|
|
predecessors.put(i, null);
|
|
}
|
|
|
|
// Erstelle Schlange wo die nächsten Verbindungen drin sind
|
|
PriorityQueue<WrapperElement<T>> queue = new PriorityQueue<>(new WrapperComparator<T>());
|
|
|
|
// Distanz zu Startknoten auf 0
|
|
// Weg zu Startknoten in die Schlange aufnehmen
|
|
distance.put(n1, 0);
|
|
queue.add(new WrapperElement<>(n1, 0));
|
|
|
|
// Variable, die Distanz zwischen aktuellem Knoten und Nachfolger speichert
|
|
int dist = 0;
|
|
// Zähler für LogList
|
|
int step = 0;
|
|
// String für den Description Inhalt
|
|
String textDescription;
|
|
|
|
// Färben der Start und Ziel Knoten für Visualisierung + hinzufügen zur LogList
|
|
n1.getScreenVertex().setColor(Color.RED);
|
|
n2.getScreenVertex().setColor(Color.RED);
|
|
textDescription = "Startknoten: " + n1.getScreenVertex().getMarking()
|
|
+ ", Endknoten: " + n2.getScreenVertex().getMarking();
|
|
this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
|
|
|
|
while (!queue.isEmpty()) {
|
|
// Den nächsten Knoten, der am wenigsten kostet, besuchen
|
|
WrapperElement<T> nextVertex = queue.poll();
|
|
|
|
// Falls Knoten schon besucht
|
|
if(!visited.get(nextVertex.getElement())){
|
|
// Knoten als besucht makieren
|
|
visited.put(nextVertex.getElement(), true);
|
|
textDescription = "Visit " + nextVertex.getElement().getName();
|
|
// Logging
|
|
System.out.println(textDescription);
|
|
nextVertex.getElement().getScreenVertex().setColor(Color.BLUE);
|
|
this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
|
|
}
|
|
|
|
|
|
// Wenn Weg gefunden, brich ab
|
|
if (nextVertex.getElement() == n2) {
|
|
MarkedVertex<T> colorroute = n2;
|
|
while (colorroute != null) {
|
|
textDescription = colorroute.getName();
|
|
System.out.println(textDescription);
|
|
colorroute.getScreenVertex().setColor(Color.green);
|
|
this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
|
|
|
|
colorroute = predecessors.get(colorroute);
|
|
}
|
|
|
|
|
|
//zurücksetzten der Färbungen
|
|
this.clearScreenGraphColor();
|
|
return distance.get(n2);
|
|
}
|
|
|
|
|
|
// Gehe von diesem Knoten aus alle erreichbaren Knoten durch
|
|
for (MarkedVertex<T> i: this.getNeighbours(nextVertex.getElement())) {
|
|
|
|
// Kante finde, die den jetzigen und nächsten Knoten verbindet
|
|
for (MarkedEdge<U> j: this.getAllEdges()) {
|
|
if (j.getSource() == nextVertex.getElement() && j.getDestination() == i) {
|
|
|
|
// Berechne Distanz zu nächstem Knoten
|
|
EdgeWeightMarking marking = (EdgeWeightMarking) j.getMarking();
|
|
dist = distance.get(nextVertex.getElement()) + marking.getWeight();
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Wenn es schon einen kürzeren Weg zum Knoten gibt, überspringen
|
|
if ((distance.get(i) <= dist && distance.get(i) != -1) || visited.get(i)) {
|
|
continue;
|
|
}
|
|
|
|
// Vorgänger aktualisieren
|
|
predecessors.put(i, nextVertex.getElement());
|
|
|
|
// Aktualisiere Distanz von Start zu nächstem Knoten
|
|
distance.put(i, dist);
|
|
|
|
// Logging
|
|
textDescription = "Add " + i.getName() + " with " + dist + " weight to queue.";
|
|
System.out.println(textDescription);
|
|
i.getScreenVertex().setColor(Color.YELLOW);
|
|
this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
|
|
|
|
// Nehme nächsten Knoten in die Queue auf
|
|
queue.add(new WrapperElement<>(i, dist));
|
|
}
|
|
}
|
|
|
|
//zurücksetzten der Färbungen
|
|
this.clearScreenGraphColor();
|
|
|
|
MarkedVertex<T> colorroute = n2;
|
|
while (colorroute != null) {
|
|
textDescription = colorroute.getName();
|
|
System.out.println(textDescription);
|
|
colorroute.getScreenVertex().setColor(Color.green);
|
|
this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
|
|
|
|
colorroute = predecessors.get(colorroute);
|
|
}
|
|
|
|
System.out.println("Done");
|
|
// Gibt Distanz zu gefragtem Knoten zurück
|
|
return distance.get(n2);
|
|
}
|
|
|
|
|
|
public double getShortestPathAStar(MarkedVertex<T> n1, MarkedVertex<T> n2) {
|
|
|
|
// Erstellt Hashmap um Distanz von Startnoten zu jedem Knoten auf dem Graph zu tracken
|
|
// Erstellt Hashmap um zu tracken welche Knoten schon besucht wurden
|
|
// Erstelle Hashmap um Vorgängerknoten zu tracken
|
|
// Initialisierung aller Distanzen auf UNENDLICH (= -1)
|
|
// Initialisierung, dass kein Knoten besucht wurde
|
|
// Initialisierung aller Vorgänger auf null
|
|
HashMap<MarkedVertex<T>, Double> distance = new HashMap<>();
|
|
HashMap<MarkedVertex<T>, Boolean> visited = new HashMap<>();
|
|
HashMap<MarkedVertex<T>, MarkedVertex<T>> predecessors = new HashMap<>();
|
|
for (MarkedVertex<T> i: this.getAllVertexes()) {
|
|
distance.put(i, -1.0);
|
|
visited.put(i, false);
|
|
predecessors.put(i, null);
|
|
}
|
|
|
|
// Erstelle Schlange wo die nächsten Verbindungen drin sind
|
|
PriorityQueue<WrapperElement<T>> queue = new PriorityQueue<>(new WrapperComparator<T>());
|
|
|
|
// Distanz zu Startknoten auf 0
|
|
// Weg zu Startknoten in die Schlange aufnehmen
|
|
distance.put(n1, 0.0);
|
|
queue.add(new WrapperElement<>(n1, 0));
|
|
|
|
// Variable, die Distanz zwischen aktuellem Knoten und Nachfolger speichert
|
|
double dist = 0;
|
|
// Variable, die Distanz zwischen dem potenziell nächsten Knoten und dem Zielknoten speichert
|
|
double airDist = 0;
|
|
// Variable, die Distanz zwischen dem aktuellen Knoten bis zum Endknoten speichert
|
|
double distToFinish = 0;
|
|
// Zähler für LogList
|
|
int step = 0;
|
|
// String für den Description Inhalt
|
|
String textDescription;
|
|
|
|
// Färben der Start und Ziel Knoten für Visualisierung + hinzufügen zur LogList
|
|
n1.getScreenVertex().setColor(Color.RED);
|
|
n2.getScreenVertex().setColor(Color.RED);
|
|
textDescription = "Startknoten: " + n1.getScreenVertex().getMarking()
|
|
+ ", Endknoten: " + n2.getScreenVertex().getMarking();
|
|
this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
|
|
|
|
while (!queue.isEmpty()) {
|
|
// Den nächsten Knoten, der am wenigsten kostet, besuchen
|
|
WrapperElement<T> nextVertex = queue.poll();
|
|
|
|
// Falls Knoten schon besucht
|
|
if(!visited.get(nextVertex.getElement())){
|
|
// Knoten als besucht makieren
|
|
visited.put(nextVertex.getElement(), true);
|
|
textDescription = "Visit " + nextVertex.getElement().getName();
|
|
// Logging
|
|
System.out.println(textDescription);
|
|
nextVertex.getElement().getScreenVertex().setColor(Color.BLUE);
|
|
this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
|
|
}
|
|
|
|
// Wenn Weg gefunden, brich ab
|
|
if (nextVertex.getElement() == n2) {
|
|
MarkedVertex<T> colorroute = n2;
|
|
while (colorroute != null) {
|
|
textDescription = colorroute.getName();
|
|
System.out.println(textDescription);
|
|
colorroute.getScreenVertex().setColor(Color.green);
|
|
this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
|
|
|
|
colorroute = predecessors.get(colorroute);
|
|
}
|
|
|
|
|
|
//zurücksetzten der Färbungen
|
|
this.clearScreenGraphColor();
|
|
return distance.get(n2);
|
|
}
|
|
|
|
|
|
// Gehe von diesem Knoten aus alle erreichbaren Knoten durch
|
|
for (MarkedVertex<T> i: this.getNeighbours(nextVertex.getElement())) {
|
|
|
|
// Kante finde, die den jetzigen und nächsten Knoten verbindet
|
|
for (MarkedEdge<U> j: this.getAllEdges()) {
|
|
if (j.getSource() == nextVertex.getElement() && j.getDestination() == i) {
|
|
|
|
//Berechnung der Heuristik über die Luftdistanz des nächsten Knoten zum Zielknoten
|
|
airDist = Math.sqrt(Math.pow((i.getCords()[0] - n2.getCords()[0]), 2)
|
|
+ Math.pow((i.getCords()[1] - n2.getCords()[1]), 2)) / 100;
|
|
|
|
// Berechne Distanz zu nächstem Knoten
|
|
EdgeWeightMarking marking = (EdgeWeightMarking) j.getMarking();
|
|
dist = distance.get(nextVertex.getElement()) + marking.getWeight();
|
|
distToFinish = distance.get(nextVertex.getElement()) + marking.getWeight() + airDist;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Wenn es schon einen kürzeren Weg zum Knoten gibt, überspringen
|
|
if ((distance.get(i) <= dist && distance.get(i) != -1) || visited.get(i)) {
|
|
continue;
|
|
}
|
|
|
|
// Vorgänger aktualisieren
|
|
predecessors.put(i, nextVertex.getElement());
|
|
|
|
// Aktualisiere Distanz von Start zu nächstem Knoten
|
|
distance.put(i, dist);
|
|
|
|
// Logging
|
|
textDescription = "Add " + i.getName() + " with " + distToFinish + " weight to queue.";
|
|
System.out.println(textDescription);
|
|
i.getScreenVertex().setColor(Color.YELLOW);
|
|
this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
|
|
|
|
// Nehme nächsten Knoten in die Queue auf
|
|
queue.add(new WrapperElement<>(i, distToFinish));
|
|
}
|
|
}
|
|
|
|
//zurücksetzten der Färbungen
|
|
this.clearScreenGraphColor();
|
|
|
|
MarkedVertex<T> colorroute = n2;
|
|
while (colorroute != null) {
|
|
textDescription = colorroute.getName();
|
|
System.out.println(textDescription);
|
|
colorroute.getScreenVertex().setColor(Color.green);
|
|
this.logList.add(new OurLogElement(step, textDescription, 0, this.getScreenGraphCopy()));
|
|
|
|
colorroute = predecessors.get(colorroute);
|
|
}
|
|
|
|
System.out.println("Done");
|
|
// Gibt Distanz zu gefragtem Knoten zurück
|
|
return distance.get(n2);
|
|
}
|
|
|
|
}
|