/**
* Methode prueft, ob der gesetzte Schnittpunkt Startpunkt des getroffenen Strahls ist. Sofern
* dies der Fall ist, wird das Start-Flag gesetzt.
*/
private void isPointStart() {
// teste, ob der Schnittpunkt dem Startpunkt entspricht
MyVector3f rayStart = mHitRay.getStart();
if (rayStart.equals(mIntersection)) {
mIsStart = true;
return;
}
MyVectormath mathHelper = MyVectormath.getInstance();
// teste nun, ob die Distanz zwischen den Punkten innerhalb eines
// Toleranzbereichs liegt
// sofern dies der Fall ist, werden die Punkte als "gleich"
// angesehen
float distance = mathHelper.calculatePointPointDistance(rayStart, mIntersection);
if (mathHelper.isWithinTolerance(distance, 0.0f, 0.01f)) {
mIsStart = true;
return;
}
mIsStart = false;
}
/**
* @author Patrick Gunia Klasse implementiert ein Verfahren zur Berechnung von Grundrissen aus einer
* Menge komplexer Objekte. Das Verfahren durchlaeuft die Kanten aller Eingabegrundrisse und
* berechnet einen Polygonzug, der saemtliche eingegebenen Grundrisse enthaelt.
*/
public class FootprintMerger {
/** Logging-Instanz */
protected static Logger LOGGER = Logger.getLogger(FootprintMerger.class);
/** Instanz der Mathebibliothek */
private MyVectormath mMathHelper = MyVectormath.getInstance();
// ------------------------------------------------------------------------------------------
/**
* Methode berechnet fuer den uebergebenen Grundriss-Bucket einen gemergeten Grundriss und gibt
* diesen als Vektor von Vertex3d-Instanzen zurueck.
*
* @param bucket Bucket mit Grundrissen, die innerhalb der Methode gemerged werden
* @return Vektor mit Vertex3d-Instanzen, die den gemergten Grundriss beschreiben
*/
public List<Vertex3d> computeMergedFootprint(FootprintBucket bucket) {
LOGGER.info("Footprintbucket enthaelt: " + bucket.getFootprints().size() + " Eingabepolygone!");
Ray startRay = findStartRay(bucket);
LOGGER.trace("Startray fuer Schnittberechnungen: " + startRay);
assert startRay != null : "FEHLER: Es konnte kein Anfangsstrahl ermittelt werden!";
List<Vertex3d> resultVertices = new ArrayList<Vertex3d>();
// sammele erneut alle Strahlen aller Grundrisse ein
List<Ray> allRays = new ArrayList<Ray>();
List<Footprint> allFootprints = bucket.getFootprints();
Iterator<Footprint> footprintIter = allFootprints.iterator();
while (footprintIter.hasNext()) {
allRays.addAll(footprintIter.next().getRays());
}
Iterator<Ray> rayIter = allRays.iterator();
LOGGER.trace("Insgesamt befinden sich " + allRays.size() + " Rays im Eimer");
while (rayIter.hasNext()) {
LOGGER.trace(rayIter.next());
}
Ray currentRay = null, lastRay = null, intersectionRay = null;
MyVector3f intersectionPoint = null;
Vertex3d resultVertex = null;
// fuege Startpunkt des Startstrahls als erstes Vertex hinzu
resultVertex = new Vertex3d(startRay.getStart());
resultVertices.add(resultVertex);
// Steuervariable fuer Iterationen
Boolean doContinue = true;
// erster Treffer des Startstrahls, wird fuer Abbruchkriterium benoetigt
MyVector3f firstHit = null;
// Iteration laeuft so lange, bis Abbruchkriterium erfuellt wurde
while (doContinue) {
// 1. Iteration
if (currentRay == null) {
currentRay = startRay;
}
Hit resultHit = findIntersectingRay(currentRay, bucket, lastRay, intersectionPoint);
assert resultHit != null : "Es konnte kein Schnittstrahl ermittelt werden";
// System.out.println("Gefundener Strahl: " + intersectionRay);
intersectionRay = resultHit.getHitRay();
intersectionPoint = resultHit.getIntersection();
// speichere den ersten gefundenen Treffer
if (firstHit == null) firstHit = intersectionPoint;
// erzeuge eine Vertex3d-Instanz fuer den Schnittpunkt und fuege sie
// zum Result-Vektor hinzu
resultVertex = new Vertex3d(intersectionPoint);
// breche ab, wenn ein Vertex geadded werden soll, das bereits
// vorhanden ist
LOGGER.trace("Adde Vertex: " + resultVertex);
if (resultVertices.contains(resultVertex)) break;
else resultVertices.add(resultVertex);
// naechste Iteration vorbereiten
lastRay = currentRay;
currentRay = intersectionRay;
// Abbruchkriterium pruefen
doContinue = checkTermination(startRay, firstHit, currentRay, intersectionPoint);
}
return resultVertices;
}
// ------------------------------------------------------------------------------------------
/**
* Methode testet die Abbruchkriterien fuer die Footprintberechnung. Ein Abbruch findet statt,
* falls der aktuelle Ray mit dem dem StartRay uebereinstimmt und der Treffer nicht hinter dem
* ersten berechneten Treffer fuer den StartRay liegt.
*
* @param startRay Ausgangsstrahl, von dem ausgehend der Berechnungsalgorithmus ermittelt wird
* @param firstHit Erster Treffer auf dem Ausgangsstrahl, wird als Abbruchkriterium verwendet
* @param currentRay Ausgangsstrahl der naechsten Iteration
* @param currentHit Ermittelter Treffer auf dem aktuellen Strahl
* @return True, falls Start- und Current-Ray nicht identisch sind oder der aktuelle Treffer
* hinter dem ersten Treffer auf dem Startstrahl liegt, False sonst
*/
private Boolean checkTermination(
Ray startRay, MyVector3f firstHit, Ray currentRay, MyVector3f currentHit) {
// sind Start- und Current-Ray identisch, teste, ob der Treffer hinter
// dem ersten Treffer auf dem Strahl liegt
if (startRay.equals(currentRay)) {
Double firstHitParameter = mMathHelper.calculateParameterOnRayForPoint(firstHit, startRay);
Double currentHitParameter =
mMathHelper.calculateParameterOnRayForPoint(currentHit, currentRay);
// wenn der Parameter des aktuellen Hits groesser ist, liegt der
// Treffer hinter dem ersten Treffer
if (currentHitParameter > firstHitParameter) return true;
else return false;
}
// wenn der aktuelle Strahl vom Startstrahl abweicht, rechne weiter
else return true;
}
// ------------------------------------------------------------------------------------------
/**
* Methode durchlaeuft alle Strahlen im uebergebenen Vektor und testet auf Schnitte mit dem
* uebergebenen Strahl. Hierbei wird immer der Strahl zurueckgegeben, dessen Schnitt mit dem
* uebergebenen Strahl dem Ausgangspunkt am naechsten liegt (darum kann man auch nicht abbrechen,
* sobald man den ersten Schnitt gefunden hat)
*
* @param current Strahl, fuer den im Strahlenvektor nach Schnitten gesucht wird
* @param bucket Eimer, fuer den der gemergte Grundriss berechnet wird und der alle Strahlen fuer
* diese Rechnung enthaelt
* @param lastIntersected Im letzten Durchlauf geschnittener Strahl. So wird ein Ping-Pong-Effekt
* zwischen Iterationen vermieden
* @param lastIntersection Vektor, der den letzten berechneten Schnittpunkt beschreibt
* @return Hit-Datenstruktur, die den getroffenen Strahl sowie den Schnittpunkt enthaelt
*/
private Hit findIntersectingRay(
final Ray current,
final FootprintBucket bucket,
final Ray lastIntersected,
final MyVector3f lastIntersection) {
Ray currentTestRay = null;
float currentIntersectionDistance = Float.MAX_VALUE,
lastIntersectionDistance = -Float.MAX_VALUE;
MyVector3f currentIntersection = null;
List<Hit> hits = new ArrayList<Hit>();
Hit currentHit = null;
LOGGER.debug("Aktueller Teststrahl: " + current);
LOGGER.debug("Letzter Schnittpunkt: " + lastIntersection);
Iterator<Ray> allRayIter = bucket.getAllRays().iterator();
while (allRayIter.hasNext()) {
currentTestRay = allRayIter.next();
// sich selber nicht testen
if (currentTestRay.equals(current)) continue;
// den zuletzt geschnittenen Strahl ebenfalls ueberspringen
if (currentTestRay.equals(lastIntersected)) continue;
// sonst Schnittpunkt berechnen
currentIntersection =
mMathHelper.calculateRay2RayIntersectionApproximation(currentTestRay, current);
// Entfernung des letzten Schnittpunkts zum Startpunkt bestimmen
if (lastIntersection != null)
lastIntersectionDistance =
mMathHelper.calculatePointPointDistance(lastIntersection, current.getStart());
if (currentIntersection != null) {
// das Verfahren wird einen Strahl finden, der den Startpunkt
// des aktuellen Strahls als Endpunkt besitzt, diesen
// ueberspringen
if (currentIntersection.equals(current.getStart())) continue;
// wenn Vertices auf Strahlen liegen, kann der Fall auftreten,
// dass der Schnittpunkt des letzten Durchlaufs erneut gefunden
// wird
if (currentIntersection.equals(lastIntersection)) continue;
// logger.trace("CurrentIntersection: " + currentIntersection);
// befindet sich der Strahl auf den Liniensegmenten beider
// Teststrahlen?
if (mMathHelper.isPointOnLineSegment(currentIntersection, currentTestRay)
&& mMathHelper.isPointOnLineSegment(currentIntersection, current)) {
// sortiere solche Hits aus, bei denen der Schnittpunkt der
// Endpunkt der getroffenen Kante ist
double rayParameter =
mMathHelper.calculateParameterOnRayForPoint(currentIntersection, currentTestRay);
if (mMathHelper.isWithinTolerance(rayParameter, 1.0d, 0.001d)) {
continue;
}
// Entfernung bestimmen
currentIntersectionDistance =
mMathHelper.calculatePointPointDistance(currentIntersection, current.getStart());
// wenn der neue Schnittpunkt naeher am Startpunkt liegt,als
// der im vorheringen Startpunkt berechnete, breche ab!
// Dieser Schnittpunkt liegt auf dem Eingabestrahl und muss
// nicht mit dem Startpunkt identisch sein, darum muss
// jeder neue Schnittpunkt, der auf dem Strahl ermittelt
// wird, zwingend weiter vom Start des Eingabestrahls
// entfernt liegen
if (lastIntersectionDistance > currentIntersectionDistance) {
continue;
}
// erzeuge eine Treffer-Instanz
currentHit = new Hit(currentTestRay, currentIntersectionDistance, currentIntersection);
if (!hits.contains(currentHit)) {
hits.add(currentHit);
// logger.info("Kandidat: " + currentHit);
}
// suche nach Strahlen, die eine Verlaengerung des
// Ausgangsstrahls sind und somit durch Schnittpunkttests
// nicht gefunden werden koennen
List<Ray> additionalRays =
searchForRaysContainingGivenPoint(currentIntersection, current, bucket.getAllRays());
// wenn Strahlen gefunden wurden, adde sie zum Hit-Vetor
if (additionalRays.size() > 0) {
Ray additionalRay = null;
Iterator<Ray> additionalRayIter = additionalRays.iterator();
while (additionalRayIter.hasNext()) {
additionalRay = additionalRayIter.next();
currentHit = new Hit(additionalRay, currentIntersectionDistance, currentIntersection);
if (!hits.contains(currentHit)) {
hits.add(currentHit);
// logger.info("Kandidat: " + currentHit);
}
}
}
}
}
}
LOGGER.debug("Insgesamt wurden " + hits.size() + " potentielle Kandidaten bestimmt.");
// wenn kein Strahl gefunden wurde, werfe eine Exception
assert hits.size() > 0
: "Fehler: Es konnte kein Strahl gefunden werden, der sich mit dem Eingabestrahl schneidet! Eingabe: "
+ current;
/*
* logger.info("Potentielle Treffer: "); for(int i = 0; i < hits.size();
* i++) logger.info(hits.get(i));
*/
// es wurde nur ein Strahl getroffen
if (hits.size() == 1) {
return hits.get(0);
}
currentHit = chooseResultRay(hits, current, bucket);
if (currentHit == null) return hits.get(0);
else return currentHit;
}
// ------------------------------------------------------------------------------------------
/**
* Methode waehlt den Ergebnisstrahl aus dem uebergebenen Vektor aus und gibt diesen zurueck.
* Dadurch kapselt die Methode die gesamte Auswahllogik.
*
* @param hits Liste mit saemtlichen Trefferinstanzen
* @param current Strahl, fuer den nach Schnitten mit allen anderen Strahlen gesucht wird
* @param bucket Eimer, fuer den aktuell ein gemergter Grundriss erstellt wird
* @return Hit-Datenstruktur, die als Ausgangspunkt der naechsten Iteration dient
*/
private Hit chooseResultRay(
final List<Hit> hits, final Ray current, final FootprintBucket bucket) {
Hit currentHit = null;
// kommen mehrere Hits mit gleicher Distanz vor, fuellt man diese
// zunaechst in einen Buffer-Vector um
List<Hit> buffer = new ArrayList<Hit>();
sortHitsByDistance(hits);
float distance = Float.MAX_VALUE;
// befuelle den Buffer-Vector mit allen Hits, die die minimale Distanz
// besitzen
// 1. Hit nehmen und distance initialisieren
buffer.add(hits.get(0));
distance = hits.get(0).getDistance();
for (int i = 1; i < hits.size(); i++) {
currentHit = hits.get(i);
if (currentHit.getDistance() > distance) break;
else buffer.add(currentHit);
}
hits.clear();
// wurde nur ein Hit mit dieser Distanz gefunden, gebe diesen als
// Ergebnis zurueck
if (buffer.size() == 1) return buffer.get(0);
// an diesem Punkt hat man mehrere Strahlen mit gleicher Distanz
// fuehre einen Votingansatz durch, bei dem fuer jeden Strahl Tests
// gerechnet werden => je nach Ausgang dieser Tests wird der Vote-Count
// fuer den jeweiligen Treffer erhoeht, am Ende waehlt man den Strahl
// mit den meisten Stimmen
Iterator<Hit> hitIter = buffer.iterator();
while (hitIter.hasNext()) {
currentHit = hitIter.next();
// bevorzuge Strahlen mit unterschiedlicher Richtung
if (!hasSameDirection(currentHit, current)) currentHit.vote(1);
// bevorzuge Strahlen, die nicht zum gleichen Objekt gehoeren, wie
// der Ausgangsstrahl
// es ist wichtiger, dass der Strahl nicht zum gleichen Objekt
// gehoert, darum 2 Stimmen!
if (!isPartOfSameObject(currentHit, current, bucket)) {
currentHit.vote(2);
}
}
// sortiere die Strahlen anhand der Stimmen, die sie durch die
// Votingmethoden bekommen haben
sortHitsByVoteCount(buffer);
/*
* logger.debug("Gevotete Hits: "); for (int i = 0; i < buffer.size();
* i++) logger.debug(buffer.get(i));
*/
return buffer.get(buffer.size() - 1);
}
// ------------------------------------------------------------------------------------------
/**
* Methode sucht nach Strahlen, die den uebergebenen Schnittpunkt enthalten. Ziel ist es,
* Verlaengerungen des Eingabestrahls zu entdecken, die durch die Schnittpunkttests nicht bestimmt
* werden koennen, da es fuer die Gleichungssysteme keine gueltige Loesung gibt.
*
* @param intersection Schnittpunkt, der im aktuellen Durchlauf bestimmt wurde
* @param current Strahl, fuer den nach Schnittpunkten gesucht wird
* @param allRays Vector mit allen Strahlen, die im aktuell verarbeiteten Bucket enthalten sind
* @return Vector mit allen Strahlen, die den Schnittpunkt enthalten
*/
private List<Ray> searchForRaysContainingGivenPoint(
MyVector3f intersection, Ray current, List<Ray> allRays) {
List<Ray> result = new Vector<Ray>();
Iterator<Ray> rayIter = allRays.iterator();
Ray currentRay = null;
while (rayIter.hasNext()) {
currentRay = rayIter.next();
// skippe den Eingabestrahl
if (currentRay.equals(current)) continue;
if (mMathHelper.isPointOnRay(intersection, currentRay)) {
if (mMathHelper.isPointOnLineSegment(intersection, currentRay)) {
// sortiere solche Hits aus, bei denen der Schnittpunkt der
// Endpunkt der getroffenen Kante ist
double rayParameter =
mMathHelper.calculateParameterOnRayForPoint(intersection, currentRay);
if (mMathHelper.isWithinTolerance((float) rayParameter, 1.0f, 0.01f)) continue;
result.add(currentRay);
}
}
}
return result;
}
// ------------------------------------------------------------------------------------------
/**
* 1. Votingverfahren fuer Strahl-Auswahl: Verfahren testet, ob der getroffene Strahl und der
* Ausgangsstrahl die gleiche Richtung besitzen
*
* @param currentHit Treffer-Instanz, deren Strahlenrichtung ueberprueft wird
* @param currentRay Strahlen-Instanz, fuer die ein Nachfolger gesucht wird
* @return True, falls der Ausgangsstrahl die gleiche Richtung besitzt, wie der getroffene Strahl,
* False sonst
*/
private boolean hasSameDirection(Hit currentHit, Ray currentRay) {
MyVector3f currentHitDirection = currentHit.getHitRay().getDirection();
MyVector3f currentRayDirection = currentRay.getDirection();
// teste, ob die Strahlen parallel sind
return mMathHelper.isParallel(currentHitDirection, currentRayDirection);
}
// ------------------------------------------------------------------------------------------
/**
* 2. Votingverfahren fuer Strahlauswahl: Methode testet, ob der getroffene Strahl und der
* Ausgangsstrahl Teil des gleichen Ausgangspolygons sind
*
* @param currentHit Treffer-Instanz, fuer deren Strahl getestet wird, ob dieser zum gleichen
* Polygon gehoert, wie der Ausgangsstrahl
* @param currentRay Strahlen-Instanz, fuer die ein Nachfolger gesucht wird
* @param bucket Eimer, fuer den aktuell ein gemergter Grundriss errechnet wird
* @return True, falls beide Strahlen Kanten des gleichen Polygons sind, False sonst
*/
private boolean isPartOfSameObject(
final Hit currentHit, final Ray currentRay, final FootprintBucket bucket) {
// bestimme die Quellpolygone fuer den Trefferstrahl und den Teststrahl
List<Footprint> footprints = bucket.getFootprints();
MyPolygon currentPolygon = null;
Ray hitRay = currentHit.getHitRay();
LOGGER.debug("CURRENT RAY: " + currentRay + " HITRAY: " + hitRay);
for (int i = 0; i < footprints.size(); i++) {
currentPolygon = footprints.get(i).getFootprintPoly();
// wenn beide Strahlen im Polygon enthalten sind, gebe True zurueck
if (currentPolygon.isRayInPolygon(hitRay) && currentPolygon.isRayInPolygon(currentRay)) {
LOGGER.debug("SAME POLY");
LOGGER.debug("CUR POLY: " + currentPolygon);
return true;
}
}
return false;
}
// ------------------------------------------------------------------------------------------
/**
* Methode sortiert alle gefundenen Treffer des Ausgangsstrahls mit allen anderen Strahlen
* aufgrund ihrer Distanz zum Start der getroffenen Strahlen
*
* @param hits Liste mit allen Treffern
*/
private void sortHitsByDistance(List<Hit> hits) {
Collections.sort(
hits,
new Comparator<Hit>() {
@Override
public int compare(Hit o1, Hit o2) {
return o1.getDistance().compareTo(o2.getDistance());
}
});
}
// ------------------------------------------------------------------------------------------
/**
* Methode sortiert alle gefundenen Treffer des Ausgangsstrahls mit allen anderen Strahlen
* aufgrund der Anzahl der Stimmen, die sie waehrend der Strahlauswahl erhalten haben
*
* @param hits Vector mit allen Treffern
*/
private void sortHitsByVoteCount(List<Hit> hits) {
Collections.sort(
hits,
new Comparator<Hit>() {
@Override
public int compare(Hit o1, Hit o2) {
return o1.getVoteCount().compareTo(o2.getVoteCount());
}
});
}
// ------------------------------------------------------------------------------------------
/**
* Methode sucht innerhalb der Footprintstrukturen nach einem Strahl, von dem aus der
* Schnittalgorithmus starten kann. Der Startpunkt des Verfahrens muss ausserhalb aller anderen
* Grundrisse liegen. Ein solcher Punkt muss innerhalb der Ebene, in der der Grundriss liegt,
* einen Extremwert aufweisen.
*
* @param bucket Eimer mit einer Menge von Grundrissen, fuer die ein gemergter Grundriss erstellt
* werden soll
* @return Strahl, von dem ausgehend die Schnittberechnung erfolgt
*/
private Ray findStartRay(FootprintBucket bucket) {
Axis ignorableAxis = findRelevantComponent(bucket);
// sammele alle Rays in einer grossen Liste
List<Ray> allRays = new ArrayList<Ray>();
List<Footprint> allFootprints = bucket.getFootprints();
Iterator<Footprint> footprintIter = allFootprints.iterator();
while (footprintIter.hasNext()) {
allRays.addAll(footprintIter.next().getRays());
}
List<Ray> rayBuffer = new ArrayList<Ray>();
// initialisiere auf maximal moeglichen Float-Wert
float minValueForRelevantComponent = Float.MAX_VALUE;
Ray currentStart = null, currentRay = null;
MyVector3f currentPos = null;
// suche jetzt den Strahl, der bezueglich der relevanten Komponente den
// kleinsten Wert besitzt, dies ist der Start-Strahl
Iterator<Ray> rayIter = allRays.iterator();
while (rayIter.hasNext()) {
currentRay = rayIter.next();
currentPos = currentRay.getStartPtr();
// durchlaufe alle Rays und suche denjenigen, der zunaechst in einer
// Komponente den kleinsten Wert besitzt
// die Entscheidung, welche Komponente getestet wird, haengt von der
// Achse ab, die vorab als "ignorierbar" bestimmt wurde
switch (ignorableAxis) {
// x
case X:
if (currentPos.z <= minValueForRelevantComponent) {
minValueForRelevantComponent = currentPos.z;
// adde den Ray am Start des Buffers => dadurch befinden
// sich die Rays mit den kleinsten Werten am Ende vorne
rayBuffer.add(0, currentRay);
}
break;
// y
case Y:
if (currentPos.x <= minValueForRelevantComponent) {
minValueForRelevantComponent = currentPos.x;
rayBuffer.add(0, currentRay);
}
break;
// z
case Z:
if (currentPos.y <= minValueForRelevantComponent) {
minValueForRelevantComponent = currentPos.y;
rayBuffer.add(0, currentRay);
}
break;
// Fehler
default:
assert false : "Die berechnete relevante Komponente ist ungueltig: " + ignorableAxis;
break;
}
}
// durchlaufe den Buffer und pruefe, ob mehrere Rays mit gleicher
// Komponente vorkommen
rayIter = rayBuffer.iterator();
minValueForRelevantComponent = Float.MAX_VALUE;
// entferne nun alle Strahlen, deren Wert ueber dem aktuellen Minimum
// liegt
while (rayIter.hasNext()) {
currentRay = rayIter.next();
currentPos = currentRay.getStartPtr();
switch (ignorableAxis) {
// x
case X:
if (currentPos.z <= minValueForRelevantComponent) {
minValueForRelevantComponent = currentPos.z;
}
// Komponentenwert liegt ueber dem aktuellen Minimum =>
// entfernen
else rayIter.remove();
break;
// y
case Y:
if (currentPos.x <= minValueForRelevantComponent) {
minValueForRelevantComponent = currentPos.x;
} else rayIter.remove();
break;
// z
case Z:
if (currentPos.y <= minValueForRelevantComponent) {
minValueForRelevantComponent = currentPos.y;
} else rayIter.remove();
break;
}
}
// wenn es nur noch einen Strahl gibt, hat man sein Ergebnis
if (rayBuffer.size() == 1) return rayBuffer.get(0);
// Kontrollwert zuruecksetzen
minValueForRelevantComponent = Float.MAX_VALUE;
// sonst muss noch eine zweite Komponente geprueft werden
// erneuter Switch mit Test auf die verbleibende Komponente:
rayIter = rayBuffer.iterator();
while (rayIter.hasNext()) {
currentRay = rayIter.next();
currentPos = currentRay.getStartPtr();
switch (ignorableAxis) {
// x
case X:
if (currentPos.y < minValueForRelevantComponent) {
minValueForRelevantComponent = currentPos.y;
currentStart = currentRay;
}
break;
// y
case Y:
if (currentPos.z < minValueForRelevantComponent) {
minValueForRelevantComponent = currentPos.z;
currentStart = currentRay;
}
break;
// z
case Z:
if (currentPos.x < minValueForRelevantComponent) {
minValueForRelevantComponent = currentPos.x;
currentStart = currentRay;
}
break;
}
}
// jetzt hat man einen Strahl, der in beiden Komponenten minimal ist
return currentStart;
}
// ------------------------------------------------------------------------------------------
/**
* Methode analysiert die Grundrissebenen und verwendet deren Normalenvektoren, um zu bestimmen,
* welcher Koordinatenebene deren Ausrichtungen am naechsten kommen, indem die Komponente mit dem
* groessten absoluten Wert des Normalenvektors ermittelt wird. Diese wird zurueckgereicht
*
* @param bucket Bucket mit Grundrissen, die innerhalb der Methode gemerged werden
* @return Achse, die fuer eine Projektion ignoriert werden koennte
*/
private Axis findRelevantComponent(FootprintBucket bucket) {
Footprint currentFootprint = null;
MyVector3f planeNormal = null;
List<Footprint> footprints = bucket.getFootprints();
Iterator<Footprint> footprintIter = footprints.iterator();
Axis relevantComponent = Axis.UNKNOWN;
Axis resultComponent = Axis.UNKNOWN;
while (footprintIter.hasNext()) {
currentFootprint = footprintIter.next();
// hole die Normale und suche eine Komponente mit Wert 0
planeNormal = currentFootprint.getFootprintPoly().getNormal();
// bestimme die Koordinatenkomponente mit dem groessten absoluten
// Wert
relevantComponent = mMathHelper.getIgnorableAxis(planeNormal, false);
// validiere, dass alle Grundrisse die gleiche Ausrichtung besitzen
if (resultComponent != Axis.UNKNOWN && relevantComponent != resultComponent) {
assert false
: "Planes mit unterschiedlichen Ausrichtungen der Normalenvektoren im gleichen Bucket";
} else resultComponent = relevantComponent;
}
return resultComponent;
}
// ------------------------------------------------------------------------------------------
/**
* @author Patrick Gunia
* <p>Instanzen dieser Klasse speichern alle Informationen ueber gefundene Treffer waehrend
* der Schnittpunkberechnungen zwischen Strahlen waehrend der Footprintbestimmung
*/
private class Hit {
/** Strahl, mit dem der Schnittpunkt berechnet wurde */
private Ray mHitRay = null;
/**
* Entfernung des gefundenen Schnittpunkts vom Ausgangsstrahl, also des Strahls, fuer den
* Schnitte gesucht werden
*/
private Float mDistance = null;
/** Speichert, ob der gefundene Schnittpunkt Startpunkt des gespeicherten Strahls ist */
private boolean mIsStart = false;
/** Berechneter Schnittpunkt */
private MyVector3f mIntersection = null;
/**
* Fuer die Treffer werden unterschiedliche Tests durchgefuehrt, um zu entscheiden, welcher
* Treffer Ausgnagspunkt fuer die naechste Iteration ist. Bei jedem Test, der fuer einen Hit
* entscheided, inkrementiert man den Hit-Count und waehlt anschliessend den Strahl mit den
* meisten Stimmen
*/
private int mVoteCount = 0;
// ------------------------------------------------------------------------------------------
/**
* @param mHitRay
* @param mDistance
* @param mIsStart
*/
public Hit(Ray mHitRay, float mDistance, MyVector3f intersection) {
super();
this.mHitRay = mHitRay;
this.mDistance = mDistance;
this.mIntersection = intersection;
// stelle fest, ob der gefundene Schnittpunkt Startpunkt des
// getroffenen Strahls ist
isPointStart();
}
// ------------------------------------------------------------------------------------------
/** @return the mHitRay */
public Ray getHitRay() {
return mHitRay;
}
// ------------------------------------------------------------------------------------------
/** @return the mDistance */
public Float getDistance() {
return mDistance;
}
// ------------------------------------------------------------------------------------------
/** @return the mIsStart */
public boolean isStart() {
return mIsStart;
}
// ------------------------------------------------------------------------------------------
/** @return the mIntersection */
public MyVector3f getIntersection() {
return mIntersection;
}
// ------------------------------------------------------------------------------------------
/**
* Methode prueft, ob der gesetzte Schnittpunkt Startpunkt des getroffenen Strahls ist. Sofern
* dies der Fall ist, wird das Start-Flag gesetzt.
*/
private void isPointStart() {
// teste, ob der Schnittpunkt dem Startpunkt entspricht
MyVector3f rayStart = mHitRay.getStart();
if (rayStart.equals(mIntersection)) {
mIsStart = true;
return;
}
MyVectormath mathHelper = MyVectormath.getInstance();
// teste nun, ob die Distanz zwischen den Punkten innerhalb eines
// Toleranzbereichs liegt
// sofern dies der Fall ist, werden die Punkte als "gleich"
// angesehen
float distance = mathHelper.calculatePointPointDistance(rayStart, mIntersection);
if (mathHelper.isWithinTolerance(distance, 0.0f, 0.01f)) {
mIsStart = true;
return;
}
mIsStart = false;
}
// ------------------------------------------------------------------------------------------
/**
* Inkemenentiert den Vote-Count fuer den aktuellen Hit um den uebergebenen Wert
*
* @param voteCount Anzahl der Stimmen, um die der Count geaendert wird, kann auch negativ sein
*/
public void vote(int voteCount) {
mVoteCount += voteCount;
}
// ------------------------------------------------------------------------------------------
/** @return the mVoteCount */
public Integer getVoteCount() {
return mVoteCount;
}
// ------------------------------------------------------------------------------------------
/*
* (non-Javadoc)
*
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return "Hit: Strahl: "
+ mHitRay
+ ", Distanz:"
+ mDistance
+ ", Schnittpunkt:"
+ mIntersection
+ ", Votes: "
+ mVoteCount;
}
// ------------------------------------------------------------------------------------------
/*
* (non-Javadoc)
*
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + getOuterType().hashCode();
result = prime * result + ((mDistance == null) ? 0 : mDistance.hashCode());
result = prime * result + ((mHitRay == null) ? 0 : mHitRay.hashCode());
result = prime * result + ((mIntersection == null) ? 0 : mIntersection.hashCode());
return result;
}
// ------------------------------------------------------------------------------------------
/*
* (non-Javadoc)
*
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
Hit other = (Hit) obj;
if (!getOuterType().equals(other.getOuterType())) return false;
if (mDistance == null) {
if (other.mDistance != null) return false;
} else if (!mDistance.equals(other.mDistance)) return false;
if (mHitRay == null) {
if (other.mHitRay != null) return false;
} else if (!mHitRay.equals(other.mHitRay)) return false;
if (mIntersection == null) {
if (other.mIntersection != null) return false;
} else if (!mIntersection.equals(other.mIntersection)) return false;
return true;
}
private FootprintMerger getOuterType() {
return FootprintMerger.this;
}
}
// ------------------------------------------------------------------------------------------
}