ProjektGraph/visualizationElements/Graph.java
2024-07-02 21:13:30 +02:00

223 lines
4.7 KiB
Java

/**
*
*/
package visualizationElements;
import java.awt.*;
import java.util.Vector;
/**
* Represents a graph to visualize search algorithms.
* @author MSchaefer
*
*/
public class Graph extends VisualizationElement{
private Vector<Vertex> vertexes;
private Vector<Edge> edges;
private boolean isDirected;
private EdgeStyle edgeStyle;
/**
* Creates a new Graph.
* @param vertexes Vertexes containing to the graph.
* @param edges Edge containing to the graph.
* @param isDirected Value whether the graph is directed or undirected.
* @param edgeStyle Value in which style the edges will be drawn.
*/
public Graph(Vector<Vertex> vertexes, Vector<Edge> edges, boolean isDirected, EdgeStyle edgeStyle){
this.setVertexes(vertexes);
this.setEdges(edges);
this.setDirected(isDirected);
this.setEdgeStyle(edgeStyle);
}
@Override
public void draw(Graphics g){
if(g != null){
// draw edges
for(Edge edge : edges){
g.setColor(edge.getColor());
if(this.isDirected){
if(this.edgeStyle == EdgeStyle.Direct){
drawDirectedDirectEdge(g, edge);
}
else{
drawDirectedAngeledEdge(g, edge);
}
}
// undirected Graph
else{
if(this.edgeStyle == EdgeStyle.Direct){
drawUndirectedDirectEdge(g, edge);
}
// angeled edges
else{
drawUndirectedAngeledEdge(g, edge);
}
}
}
// draw all vertexes and print names marking
for(Vertex vertex : vertexes){
vertex.draw(g);
}
}
}
/**
* @param isDirected the isDirected to set
*/
public void setDirected(boolean isDirected) {
this.isDirected = isDirected;
}
/**
* @return the isDirected
*/
public boolean isDirected() {
return isDirected;
}
/**
* @param edgeStyle the edgeStyle to set
*/
public void setEdgeStyle(EdgeStyle edgeStyle) {
this.edgeStyle = edgeStyle;
}
/**
* @return the edge style
*/
public EdgeStyle getEdgeStyle() {
return edgeStyle;
}
/**
*
* @param vertexes The vertexes of the graph.
*/
public void setVertexes(Vector<Vertex> vertexes) {
this.vertexes = vertexes;
}
/**
*
* @return the graph's vertexes.
*/
public Vector<Vertex> getVertexes() {
return vertexes;
}
/**
*
* @param edges The edges of the graph.
*/
public void setEdges(Vector<Edge> edges) {
this.edges = edges;
}
/**
*
* @return the graph's edges.
*/
public Vector<Edge> getEdges() {
return edges;
}
/**
* Draws an directed angled edge.
* @param g Graphics object to draw to drawArea.
* @param edge The edge to draw.
*/
private void drawDirectedAngeledEdge(Graphics g, Edge edge) {
// if the edge is a loop draw a rectangle
if(edge.getSource() == edge.getDestination()){
//edge.drawDirectedAngeledLoop(g);
edge.drawDirectedLoop(g);
}
else{
edge.drawDirectedAngeledEdge(g);
}
}
/**
* Draws an directed direct edge.
* @param g Graphics object to draw to drawArea.
* @param edge The edge to draw.
*/
private void drawDirectedDirectEdge(Graphics g, Edge edge){
//drawArrow(g, edge);
if(edge.getSource() == ((Edge) edge).getDestination()){
edge.drawDirectedLoop(g);
}
else{
edge.drawDirectedDirectEdge(g);
}
}
/**
* Draws an undirected direct Edge.
* @param g Graphics object to draw to drawArea.
* @param edge The edge to draw.
*/
private void drawUndirectedDirectEdge(Graphics g, Edge edge) {
// if there is an double edge draw two lines
if(hasEdge(edge.getSource(), edge.getDestination()) && hasEdge(edge.getDestination(), edge.getSource()) && edge.getSource() != edge.getDestination()){
edge.drawUndirectedDirectDoubleEdge(g);
}
else{
// if the edge is a loop draw a oval, otherwise draw a line from source to destination
if(edge.getSource() == edge.getDestination()){
edge.drawUndirectedLoop(g);
}
else{
edge.drawUndirectedDirectEdge(g);
}
}
}
/**
* Draws an undirected angled Edge.
* @param g Graphics object to draw to drawArea.
* @param edge The edge to draw.
*/
private void drawUndirectedAngeledEdge(Graphics g, Edge edge) {
// if the edge is a loop draw a rectangle
if(edge.getSource() == ((Edge) edge).getDestination()){
edge.drawUndirectedAngeledLoop(g);
}
else{
edge.drawUndirectedAngledEdge(g);
}
}
/**
* Decides whether the graph has an edge between two vertexes.
* @param source The source vertex.
* @param destination The destination vertex.
* @return True if there is an edge between the two vertexes, false otherwise.
*/
private boolean hasEdge(Vertex source, Vertex destination) {
for(Edge edge : edges){
if (edge.getSource() == source && edge.getDestination() == destination)
return true;
}
return false;
}
}