/*
* Datei: DargestellterGraph.java
* Autor(en): Lukas König
* Java-Version: 1.4
* Erstellt (vor): 19.09.2006
*
* (c) This file and the EAS (Easy Agent Simulation) framework containing it
* is protected by Creative Commons by-nc-sa license. Any altered or
* further developed versions of this file have to meet the agreements
* stated by the license conditions.
*
* In a nutshell
* -------------
* You are free:
* - to Share -- to copy, distribute and transmit the work
* - to Remix -- to adapt the work
*
* Under the following conditions:
* - Attribution -- You must attribute the work in the manner specified by the
* author or licensor (but not in any way that suggests that they endorse
* you or your use of the work).
* - Noncommercial -- You may not use this work for commercial purposes.
* - Share Alike -- If you alter, transform, or build upon this work, you may
* distribute the resulting work only under the same or a similar license to
* this one.
*
* + Detailed license conditions (Germany):
* http://creativecommons.org/licenses/by-nc-sa/3.0/de/
* + Detailed license conditions (unported):
* http://creativecommons.org/licenses/by-nc-sa/3.0/deed.en
*
* This header must be placed in the beginning of any version of this file.
*/
package eas.startSetup.marbBuilder;
import eas.startSetup.ParCollection;
import eas.startSetup.marbBuilder.graph.Knoten;
import java.awt.Point;
import java.awt.Polygon;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
/**
* Klasse zur Speicherung eines geometrisches Objekt, das sich aus
* Knotenpunkten, Pfeilen und Beschriftungen, denen jeweils Koordinaten
* zugeordnet sind, zusammensetzt.
*
* @author Lukas König.
*/
public class DargestellterGraph implements Serializable {
/**
* Die Serial Version ID (generiert am 25. April 2007).
*/
private static final long serialVersionUID = 3550176063237357036L;
/**
* Koordinaten der Knotenpunkte.
*/
private ArrayList<Point> knotenpunktKoord;
/**
* Ein ausgezeichneter Knoten.
*/
private int selektiert;
/**
* Objekte, die dem entsprechenden Knotenpunkt zugeordnet sind.
*/
private ArrayList<Knoten> knotenpunktObjekte;
/**
* Koordinaten aller Punkte, die Anfangspunkt eines Pfeils sind.
* Dazu gehört ein entsprechender Endpunkt.
*/
private ArrayList<Point> pfeilUrspruenge;
/**
* Koordinaten aller Punkte, die Endpunkt eines Pfeils sind (hier ist ggf.
* eine Spitze zu zeichnen). Dazu gehört ein entsprechender Anfangspunkt.
*/
private ArrayList<Point> pfeilEndpunkte;
/**
* Die Stärke eines Pfeils.
*/
private ArrayList<Double> staerken;
/**
* Ob der Pfeil gebogen sein soll.
*/
private ArrayList<Boolean> gebogen;
/**
* Liste von Strings, die in der Grafik platziert werden. Dazu gehört eine
* Koordinate.
*/
private ArrayList<String> beschriftungen;
/**
* Koordinaten der linken untere Ecke eines Strings. Dazu gehört ein
* String.
*/
private ArrayList<Point> beschrKoordinaten;
/**
* Assoziationen der Beschriftungen zu Kanten (oder Knoten?).
*/
private ArrayList<Polygon> beschrAssoz;
private ParCollection pars;
/**
* Konstruktor, der alle Attribute initialisiert.
*/
public DargestellterGraph(final ParCollection params) {
this.pars = params;
this.beschriftungen = new ArrayList<String>();
this.beschrKoordinaten = new ArrayList<Point>();
this.knotenpunktKoord = new ArrayList<Point>();
this.knotenpunktObjekte = new ArrayList<Knoten>();
this.pfeilEndpunkte = new ArrayList<Point>();
this.pfeilUrspruenge = new ArrayList<Point>();
this.beschrAssoz = new ArrayList<Polygon>();
this.staerken = new ArrayList<Double>();
this.gebogen = new ArrayList<Boolean>();
this.selektiert = -1;
}
/**
* Gibt die Liste der Knotenkoordinaten zurück.
*
* @return Die Liste der Knotenkoordinaten.
*/
public ArrayList<Point> holeKnotenKoord() {
return this.knotenpunktKoord;
}
/**
* Gibt die Liste der Knotenobjekte zurück.
*
* @return Die Liste der Knotenobjekte.
*/
public ArrayList<Knoten> holeKnotenObj() {
return this.knotenpunktObjekte;
}
/**
* Gibt die Liste der Pfeilursprungskoordinaten zurück.
*
* @return Die Liste der Pfeilursprungskoordinaten.
*/
public ArrayList<Point> holePfeilUrspr() {
return this.pfeilUrspruenge;
}
/**
* Gibt die Liste der Pfeilendkoordinaten zurück.
*
* @return Die Liste der Pfeilendkoordinaten.
*/
public ArrayList<Point> holePfeilEnd() {
return this.pfeilEndpunkte;
}
/**
* Gibt die Liste der PfeilStärken zurück.
*
* @return Die Liste der PfeilStärken.
*/
public ArrayList<Double> holePfeilStaerken() {
return this.staerken;
}
/**
* Gibt die Liste der Pfeilbiegungen zurück.
*
* @return Die Liste der Pfeilbiegungen.
*/
public ArrayList<Boolean> holePfeilBiegung() {
return this.gebogen;
}
/**
* Gibt die Liste der Beschriftungen zurück.
*
* @return Die Liste der Beschriftungen.
*/
public ArrayList<String> holeBeschr() {
return this.beschriftungen;
}
/**
* Gibt zurück, welches Objekt mit der Beschriftung assoziiert ist.
*
* @param beschr String der Beschriftung.
*
* @return Assoziation, die zu der Beschriftung gehört. Falls es keine
* gibt, wird <code>null</code> zurückgegeben.
*/
public Polygon holeAssoz(final String beschr) {
int i = 0;
while (i < this.beschriftungen.size()) {
if (this.beschriftungen.get(i) == beschr) {
return this.beschrAssoz.get(i);
}
i++;
}
return null;
}
/**
* Gibt die Liste der Beschriftungskoordinaten zurück.
*
* @return Die Liste der Beschriftungskoordinaten.
*/
public ArrayList<Point> holeBeschrKoord() {
return this.beschrKoordinaten;
}
// /**
// * Fügt der Liste der Knotenkoordinaten einen neuen Punkt hinzu und
// * assoziiert in der Liste der Knotenobjekte <code>obj</code> damit.
// *
// * @param x X-Koordinate des neuen Knotenpunktes.
// * @param y Y-Koordinate des neuen Knotenpunktes.
// * @param obj Das Objekt, welches zu diesen Koordinaten gehört.
// */
// public void hinzuKnoten(final int x,
// final int y,
// final Object obj) {
// final Point p = new Point(x, y);
// this.knotenpunktKoord.add(p);
// this.knotenpunktObjekte.add(obj);
// }
/**
* Fügt der Liste der Knotenkoordinaten einen neuen Punkt hinzu und
* assoziiert in der Liste der Knotenobjekte <code>obj</code> damit.
*
* @param x X-Koordinate des neuen Knotenpunktes.
* @param y Y-Koordinate des neuen Knotenpunktes.
* @param obj Das Objekt, welches zu diesen Koordinaten gehört.
* @param sel Gibt an, ob der Knoten selektiert ist.
*/
public void hinzuKnoten(final int x,
final int y,
final Knoten obj,
final boolean sel) {
final Point p = new Point(x, y);
this.knotenpunktKoord.add(p);
this.knotenpunktObjekte.add(obj);
if (sel) {
this.selektiert = this.knotenpunktKoord.size() - 1;
}
}
/**
* Fügt einen neuen Pfeil hinzu, das heißt es wird ein neuer Pfeilursprung
* und ein neues Pfeilende in die entsprechenden Listen eingefügt.
*
* @param x1 X-Koordinate des Anfangspunktes.
* @param y1 Y-Koordinate des Anfangspunktes.
* @param x2 X-Koordinate des Endpunktes.
* @param y2 Y-Koordinate des Endpunktes.
* @param staerke Die Stärke des Pfeils.
* @param gebogenerPfeil Ob der Pfeil gebogen sein soll / darf.
*/
public void hinzuPfeil(final int x1, final int y1,
final int x2, final int y2,
final double staerke,
final boolean gebogenerPfeil) {
final Point p1 = new Point(x1, y1);
final Point p2 = new Point(x2, y2);
this.pfeilUrspruenge.add(p1);
this.pfeilEndpunkte.add(p2);
this.staerken.add(staerke);
this.gebogen.add(gebogenerPfeil);
}
/**
* Fügt eine Beschriftung hinzu, das heißt es wird eine neue Beschriftung
* und ein Koordinatenpunkt in die entsprechenden Listen eingefßgt.
*
* @param x Linke untere X-Koordinate des Strings.
* @param y Linke untere Y-Koordinate des Strings.
* @param s Darzustellender String.
*/
public void hinzuBeschr(final int x, final int y, final String s) {
// final Point p = new Point(x, y);
//
// this.beschriftungen.add(s);
// this.beschrKoordinaten.add(p);
this.hinzuBeschr(x, y, s, null);
}
/**
* Fügt eine Beschriftung hinzu, das heißt es wird eine neue Beschriftung
* und ein Koordinatenpunkt in die entsprechenden Listen eingefügt.
* Die Beschriftung wird zusätzlich mit einer Kante assoziiert.
*
* @param x Linke untere X-Koordinate des Strings.
* @param y Linke untere Y-Koordinate des Strings.
* @param s Darzustellender String.
* @param p Polygon aus 2 Punkten; der erste stellt den Anfangspunkt,
* der zweite den Endpunkt der Kante dar.
*/
public void hinzuBeschr(final int x,
final int y,
final String s,
final Polygon p) {
final Point pt = new Point(x, y);
if (this.pars == null || this.pars.getParValueBoolean("showEALabels?")) {
this.beschriftungen.add(s);
this.beschrKoordinaten.add(pt);
this.beschrAssoz.add(p);
}
}
/**
* Gibt eine Liste aller Knoten zurück (das sind die Knotenobjekte selbst,
* im Unterschied dazu wird in der Methode holeUmPkt eine Liste der
* Koordinaten aller Knoten erzeugt), die sich in einem Rechteck der
* SeitenLänge <code>2 * radius</code> um <code>x</code> und <code>y</code>
* befinden UND den minimalen Abstand zu <code>x</code> und <code>y</code>
* haben. Der Abstand ist dabei definiert durch den Satz des Pythagoras.
*
* @param x X-Koordinate des Mittelpunkts des Rechtecks.
* @param y Y-Koordinate des Mittelpunkts des Rechtecks.
* @param radius Größe des Rechtecks, aus welchem alle Punkte
* zurückgegeben werden sollen.
*
* @return Die Knoten innerhalb des oben beschriebenen Rechtecks.
*/
public ArrayList<Knoten> holeUmObj(final int x,
final int y,
final double radius) {
final ArrayList<Knoten> knotenListe = new ArrayList<Knoten>();
final ArrayList<Point> koordListe = new ArrayList<Point>();
final ArrayList<Knoten> endListe = new ArrayList<Knoten>();
Point aktPunkt;
Knoten aktObj;
Iterator<Point> itKoord;
Iterator<Knoten> itObj;
double minAbs = Double.MAX_VALUE;
double aktAbs;
final double dX = x;
final double dY = y;
double dXAkt;
double dYAkt;
// Erzeuge Liste der Knoten in Rechteck
itKoord = this.knotenpunktKoord.iterator();
itObj = this.knotenpunktObjekte.iterator();
while (itKoord.hasNext() && itObj.hasNext()) {
aktPunkt = itKoord.next();
aktObj = itObj.next();
if (Math.abs(aktPunkt.x - x) <= radius
&& Math.abs(aktPunkt.y - y) <= radius) {
dXAkt = aktPunkt.x;
dYAkt = aktPunkt.y;
aktAbs = Math.sqrt(Math.pow(dX - dXAkt, 2)
+ Math.pow(dY - dYAkt, 2));
if (aktAbs < minAbs) {
minAbs = aktAbs;
knotenListe.add(aktObj);
koordListe.add(aktPunkt);
}
}
}
// Erzeuge Liste der Knoten mit minimalem Abstand zum angeg. Punkt.
itKoord = koordListe.iterator();
itObj = knotenListe.iterator();
while (itKoord.hasNext() && itObj.hasNext()) {
aktPunkt = itKoord.next();
aktObj = itObj.next();
dXAkt = aktPunkt.x;
dYAkt = aktPunkt.y;
aktAbs = Math.sqrt(Math.pow(dX - dXAkt, 2)
+ Math.pow(dY - dYAkt, 2));
if (aktAbs <= minAbs) {
endListe.add(aktObj);
}
}
return endListe;
}
/**
* Gibt eine Liste aller Punkte zurück, die sich in einem Rechteck der
* SeitenLänge <code>2 * radius</code> um <code>x</code> und <code>y</code>
* befinden.
*
* @param x X-Koordinate des Mittelpunkts des Rechtecks.
* @param y Y-Koordinate des Mittelpunkts des Rechtecks.
* @param radius Größe des Rechtecks, aus welchem alle Punkte
* zurückgegeben werden sollen.
*
* @return Die Punkte innerhalb des oben beschriebenen Rechtecks.
*/
public ArrayList<Point> holeUmPkt(final int x,
final int y,
final double radius) {
final ArrayList<Point> knotenListe = new ArrayList<Point>();
Point aktPunkt;
final Iterator<Point> itKoord;
itKoord = this.knotenpunktKoord.iterator();
while (itKoord.hasNext()) {
aktPunkt = itKoord.next();
if (Math.abs(aktPunkt.x - x) <= radius
&& Math.abs(aktPunkt.y - y) <= radius) {
knotenListe.add(aktPunkt);
}
}
return knotenListe;
}
/**
* Gibt zurück, ob sich p innerhalb des Rechtecks mit den Eckpunkten
* (x1, y1), (x2, y2) befindet.
*
* @param p Zu untersuchender Punkt.
* @param x1 X-Koordinate des ersten Ecks.
* @param y1 Y-Koordinate des ersten Ecks.
* @param x2 X-Koordinate des zweiten Ecks.
* @param y2 Y-Koordinate des zweiten Ecks.
*
* @return True genau dann, wenn p innerhalb des Rechtecks ist.
*/
private boolean inRechteck(final Point p,
final int x1,
final int y1,
final int x2,
final int y2) {
return ((p.x >= x1 && p.x <= x2) || (p.x <= x1 && p.x >= x2))
&& ((p.y >= y1 && p.y <= y2) || (p.y <= y1 && p.y >= y2));
}
/**
* Gibt eine Liste aller Knoten zurück, die sich in dem Rechteck, das
* durch die vier Parameter angegeben ist, befinden.
*
* @param x1 X-Koordinate des ersten Ecks des Rechtecks.
* @param y1 Y-Koordinate des ersten Ecks des Rechtecks.
* @param x2 X-Koordinate des zweiten Ecks des Rechtecks.
* @param y2 Y-Koordinate des zweiten Ecks des Rechtecks.
*
* @return Die Knoten innerhalb des oben beschriebenen Rechtecks.
*/
public ArrayList<Knoten> holeRechteck(final int x1,
final int y1,
final int x2,
final int y2) {
final ArrayList<Knoten> knotenListe = new ArrayList<Knoten>();
Point aktPunkt;
Knoten aktObj;
final Iterator<Point> itKoord;
final Iterator<Knoten> itObj;
itKoord = this.knotenpunktKoord.iterator();
itObj = this.knotenpunktObjekte.iterator();
while (itKoord.hasNext() && itObj.hasNext()) {
aktPunkt = itKoord.next();
aktObj = itObj.next();
if (this.inRechteck(aktPunkt, x1, y1, x2, y2)) {
knotenListe.add(aktObj);
}
}
return knotenListe;
}
/**
* Gibt zurück, ob das Objekt selektiert ist.
*
* @param obj Das zu untersuchende Objekt.
*
* @return Ob das Objekt selektiert ist.
*/
public boolean getSelektiert(final Object obj) {
return this.selektiert == this.knotenpunktObjekte.indexOf(obj);
}
/**
* Gibt zurück, ob ein Pfeil von (x1, y1) nach (x2, y2) vorhanden ist.
*
* @param x1 Ursprungs-X-Koordinate.
* @param y1 Ursprungs-Y-Koordinate.
* @param x2 Ziel-X-Koordinate.
* @param y2 Ziel-Y-Koordinate.
*
* @return <code>true</code>, gdw. ein Pfeil von Ursprung nach Ziel
* vorhanden ist.
*/
public boolean enthaeltPfeil(final int x1,
final int y1,
final int x2,
final int y2) {
Point p1 = new Point(x1, y1);
Point p2 = new Point(x2, y2);
int i = 0;
while (i < this.pfeilUrspruenge.size()) {
if (p1.equals(this.pfeilUrspruenge.get(i))) {
if (p2.equals(this.pfeilEndpunkte.get(i))) {
return true;
}
}
i++;
}
return false;
}
}