Methoden Methoden anpassen und fehlende Funktionen hinzufügen

D

DagobertDuck

Bekanntes Mitglied
Guten Abend,

ich melde mich erneut, um meine bisherigen Methoden noch etwas anzupassen und angenehmer für den Benutzer zu gestalten.

Es muss noch geprüft werden, ob der Start- oder Endpunkt des hinzuzufügenden Tracks mit einem Start- oder Endpunkt eines anderen Tracks verbunden ist - natürlich nur wenn !edges.isEmpty(). Im Falle einer Weiche: einer der drei Punkte muss auf einem Start- oder Endpunkt eines anderen Gleises liegen. Nur ein anderes Gleis (normales Gleis oder Weiche) kann mit einem Punkt eines Gleises verbunden werden.

Hier ist meine derzeitige addTrack() Methode:
Java: 
    public void addTrack(Track track) throws LogicException {
        /* TODO:
            - Check if start- or endpoint of the track to be added is connected with a start- or endpoint of another track - only if !edges.isEmpty().
                -> In case of a switch: one of the three points must be on a start or end point of another track.
            - Only one other track (normal track or track switch) can be connected to a point of a track.
         */
         edges.computeIfAbsent(track.getStartPoint(), x -> new ArrayList<>()).add(track);
         track.getEndPoints().forEach(p -> edges.computeIfAbsent(p, x -> new ArrayList<>()).add(track));
         ...
    }

Sollte ich hierbei mit Tiefensuche arbeiten? @mihe7 kann die isConnectedAfterRemoving() Methode ggf. einfach etwas angepasst werden?
Außerdem würde ich gerne computeIfAbsent() ersetzen: Falls der key bereits existiert, möchte ich eine Exception werfen lassen. Kann ich dies mit computeIfAbsent() bewerkstelligen, oder ist das gar nicht möglich? Falls nicht, wie kann der Code umstrukturiert werden, sodass eine Exception geworfen wird?

Ähnliches Problem habe ich mit der Methode zum Entfernen eines Tracks:
Java: 
    public void removeTrack(int trackId) {
        ...
        edges.remove(track.getStartPoint(), track.getPoints());

        //edges.computeIfAbsent(track.getStartPoint(), x -> new ArrayList<>()).remove(track);
        //track.getEndPoints().forEach(p -> edges.computeIfAbsent(p, x -> new ArrayList<>()).remove(track));
        this.tracks.remove(trackId, track);
    }

Funktioniert computeIfAbsent() im Falle des Entfernens überhaupt? Falls nicht, wie kann dies angepasst werden? edges.remove(track.getStartPoint(), track.getPoints()); funktioniert leider nicht.

Viele Grüße
 
DagobertDuck hat gesagt.:
Sollte ich hierbei mit Tiefensuche arbeiten?
Zum Vergrößern anklicken....
Nein, dazu brauchst Du doch keine Tiefensuche. Ganz einfach: edges liefert Dir zu einem gegebenen Punkt alle Gleise, die dort starten oder enden.

Java: 
//erstmal eine Abkürzung einführen
private boolean hasConnections(Point p) {
    return !edges.computeIfAbsent(p, x -> new ArrayList<>()).isEmpty();
}

public void addTrack(Track track) throws LogicException {
    if (edges.isEmpty() || hasConnections(track.getStartPoint()) || 
            track.getEndPoints().stream().anyMatch(this::hasConnections)) {
        // track hinzufügen
    } else {
        // Kein Anschlusspunkt vorhanden
    }
}

DagobertDuck hat gesagt.:
Falls der key bereits existiert, möchte ich eine Exception werfen lassen.
Zum Vergrößern anklicken....
Das ergibt wenig Sinn. Ich wiederhole mich: "edges liefert Dir zu einem gegebenen Punkt alle Gleise, die dort starten oder enden. "

DagobertDuck hat gesagt.:
Funktioniert computeIfAbsent() im Falle des Entfernens überhaupt?
Zum Vergrößern anklicken....
Ja, computeIfAbsent sorgt nur dafür, dass Du nicht null sondern einen bestimmten Wert (hier: eine leere Liste) erhältst. Aus einer Liste etwas entfernen, das in der Liste nicht vorhanden ist, ist kein Problem.

Du kannst natürlich auch explizit vorher prüfen, ob der Punkt in der Map vorhanden ist:
Java: 
    public void removeTrack(int trackId) {
        Track track = tracks.get(trackId);
        if (track == null) {
            return; // oder Exception, da Track nicht existiert
        } 
        tracks.remove(trackId);
        for (Point p : track.getPoints()) {
            if (edges.containsKey(p)) {
                edges.get(p).remove(track);
            }
        }
    }
 
Danke! An einem Punkt an einem Gleis kann immer nur ein anderes Gleis (normales Gleis oder Gleisweiche) angeschlossen werden.
Wie kann ich dies nun noch beim Hinzufügen eines neuen Tracks überprüfen und damit allerdings nicht die Funktion einer Switch blockieren?

Da ich noch nicht wirklich oft mit Sets/HashSets gearbeitet habe, habe ich die Instanziierung eines HashSets mit nur einem Element leider nicht kürzer hinbekommen:
if (!isConnectedAfterRemoving(Stream.of(track).collect(Collectors.toCollection(HashSet::new)))) - geht das auch etwas kürzer, oder ist das gut so? (Erinnerung: isConnectedAfterRemoving(Set<Track> toRemove))
 
DagobertDuck hat gesagt.:
Da ich noch nicht wirklich oft mit Sets/HashSets gearbeitet habe, habe ich die Instanziierung eines HashSets mit nur einem Element leider nicht kürzer hinbekommen:
Zum Vergrößern anklicken....
Collections.singleton(track) liefert ein Set mit dem einzigen Element track.

DagobertDuck hat gesagt.:
An einem Punkt an einem Gleis kann immer nur ein anderes Gleis (normales Gleis oder Gleisweiche) angeschlossen werden.
Wie kann ich dies nun noch beim Hinzufügen eines neuen Tracks überprüfen und damit allerdings nicht die Funktion einer Switch blockieren?
Zum Vergrößern anklicken....
Naja, wie viele Tracks dürfen denn von einem Punkt ausgehen oder an einem Punkt enden?

BTW: Die Funktion der Weiche hat damit gar nichts zu tun.
 
mihe7 hat gesagt.:
Naja, wie viele Tracks dürfen denn von einem Punkt ausgehen oder an einem Punkt enden?

BTW: Die Funktion der Weiche hat damit gar nichts zu tun.
Zum Vergrößern anklicken....

Ich habe mich vielleicht etwas unglücklich ausgedrückt. Die Funktion hat damit nichts zu tun, allerdings hängt die Anzahl der potenziell anliegenden Tracks vom Track-Typ ab.

Das reicht doch dann im Grunde genommen schon, oder?
Java: 
        if (track.isSwitch(track)) {
            // TODO: Check if number of adjacent tracks is < 3
        } else {
            // TODO: Check if number of adjacent tracks is < 2
        }

Jetzt weiß ich nicht so richtig, ob damit bereits der Fall einer Kreuzung ausgeschlossen wird (?). Also es kann ja passieren, dass eine Kreuzung durch folgenden Ablauf entsteht. So ein Fall muss damit auch abgedeckt sein.

Code: 
add switch (1,1) -> (1,2),(2,1)
add switch (2,1) -> (2,-2),(3,1)
add track (1,2) -> (2,2)
add track (2,2) -> (2,1)
 
Zuletzt bearbeitet:
Um an einen Punkt ein Gleis anschließen zu können, darf dort höchstens ein einfaches Gleis liegen, d. h. die Liste ist entweder leer oder sie enthält ein Element mit 2 Punkten.
 
Ich tue mich damit gerade etwas schwer, diese Funktion gescheit zu implementieren.

Das ist mit Sicherheit nicht richtig, aber wie würde es richtig aussehen...? Hierbei beachte ich die Endpunkte auch noch gar nicht.
Java: 
        if (track.isSwitch(track)) {
            if (getTrackConnections(track.getStartPoint()).isEmpty() || getTrackConnections(track.getStartPoint()).size() == 1) {
                return;
            } else {
                // Throw exception
            }
        } else {
            if (getTrackConnections(track.getStartPoint()).isEmpty() || getTrackConnections(track.getStartPoint()).size() == 2) {
                return;
            } else {
                // Throw exception
            }
        }

Des Weiteren hat sich herausgestellt, dass es keine Grundeinstellung für eine Weiche gibt. Ich habe die Initialisierung this.switchedTo = this.points.get(0); nun aus dem Konstruktor entfernt. Sollte ich this.switchedTo stattdessen einen anderen Wert (null o. Ä.) zuweisen?
Wirklich problematisch wird es erst bei der Instanziierung einer neuen Track, da mir nicht klar ist, was der Parameter int length beim Hinzufügen einer neuen Switch für einen Wert annehmen soll.

Beispiel:
Code: 
add track (1,1) -> (2,1)
1
add switch (2,1) -> (3,1),(2,-2)
2
list tracks
t 1 (1,1) -> (2,1) 1
s 2 (2,1) -> (3,1),(2,-2)
Die Zahl hinter den Endpunkten ist die Länge. Bei einer Switch wird dieser Wert nicht unmittelbar berechnet.

Die Länge soll also erst berechnet werden, sobald mit Hilfe des set-switch-Befehls eine Weichenstellung gewählt wurde. Wäre es nun sinnvoll, den Parameter ganz zu entfernen, oder wie löst man das Problem am besten?
 
Zuletzt bearbeitet:
DagobertDuck hat gesagt.:
Das ist mit Sicherheit nicht richtig, aber wie würde es richtig aussehen...? Hierbei beachte ich die Endpunkte auch noch gar nicht.
Zum Vergrößern anklicken....
Richtig. Das äußere if brauchst Du nicht, es bleibt nur
DagobertDuck hat gesagt.:
if (getTrackConnections(track.getStartPoint()).isEmpty() || getTrackConnections(track.getStartPoint()).size() == 2) {
Zum Vergrößern anklicken....
übrig, wobei Du track.getStartPoint() durch track.getPoints() ersetzen musst. hinten getTrackConnections(track.getStartPoint()).get(0).getPoints().size() == 2 prüfen musst.

DagobertDuck hat gesagt.:
Des Weiteren hat sich herausgestellt, dass es keine Grundeinstellung für eine Weiche gibt.
Zum Vergrößern anklicken....
Wie das?
DagobertDuck hat gesagt.:
Sollte ich this.switchedTo stattdessen einen anderen Wert (null o. Ä.) zuweisen?
Zum Vergrößern anklicken....
Wenn Du switchTo nichts zuweist, initialisiert Java automatisch mit null. Wenn es aber nur einen Endpunkt gibt, muss switchTo auf diesen gesetzt werden (normales Gleis).

DagobertDuck hat gesagt.:
da mir nicht klar ist, was der Parameter int length beim Hinzufügen einer neuen Switch für einen Wert annehmen soll.
Zum Vergrößern anklicken....
Mir auch nicht. Wozu brauchst Du den Parameter, wenn die Länge aus den Punkten berechnet wird?
 
Danke.

mihe7 hat gesagt.:
Wie das?
Zum Vergrößern anklicken....
Leider ist die Aufgabenstellung sehr undurchsichtig und wirklich realitätsnah ist dies auch nicht (?). Gibt es Weichen, die keine Weichenstellung haben...? Jedenfalls wird dies so gefordert und die Weichenstellung wird erst mit Hilfe des zugehörigen Befehls eingestellt.

mihe7 hat gesagt.:
Wenn Du switchTo nichts zuweist, initialisiert Java automatisch mit null. Wenn es aber nur einen Endpunkt gibt, muss switchTo auf diesen gesetzt werden (normales Gleis).
Zum Vergrößern anklicken....
Wieso muss switchTo bei einem normalen Gleis überhaupt gesetzt werden? Kann ich beim Fahrbetrieb nicht einfach überprüfen, ob es sich um ein normales Gleis oder eine Weiche handelt (isSwitch())?

mihe7 hat gesagt.:
Mir auch nicht. Wozu brauchst Du den Parameter, wenn die Länge aus den Punkten berechnet wird?
Zum Vergrößern anklicken....
Um z. B. beim Befehl list tracks die Länge auszugeben. Oder soll ich diese dann jedes Mal erneut berechnen? Daher hatte ich die Idee, dies direkt einmal zu speichern, was sich jetzt als schwierig erweisen wird.
 
mihe7 hat gesagt.:
Stacktrace?
Zum Vergrößern anklicken....
Code: 
add track (1,1) -> (2,1)
Exception in thread "main" java.lang.NullPointerException
    at RailNetwork.addTrack(RailNetwork.java:79)
    at Register.addTrack(Register.java:79)
    at AddTrackCommand.execute(AddTrackCommand.java:23)
    at Session.run(Session.java:48)
    at Main.main(Main.java:24)

Die Exception wird geworfen, da die Methode
Java: 
    public List<Track> getTrackConnections(Point point) {
        return edges.get(point);
    }

hier aufgerufen wird
Java: 
getTrackConnections(track.getStartPoint()).get(0).getPoints().size() != 2
obwohl es zu dem Zeitpunkt (beim Hinzufügen der allerersten Track) noch keine TrackConnections gibt und versucht wird auf das Element mit Index 0 zuzugreifen.
 
Nein, die Exception bekommst Du bereits, weil
DagobertDuck hat gesagt.:
getTrackConnections(track.getStartPoint()).isEmpty()
Zum Vergrößern anklicken....
aufgerufen wird. Du musst halt sicherstellen, dass getTrackConnectios() nicht null ist, bevor Du darauf zugreifst.

Zum Beispiel:
Java: 
List<Track> connections = getTrackConnections(track.getStartPoint());
if (connections != null && (connections.isEmpty() || connections.get(0).getPoints().size() == 2)) {
Oder eben mit
Java: 
List<Track> connections = edges.computeIfAbsent(track.getStartPoint(), () -> new ArrayList<>());
if (connections.isEmpty() || connections.get(0).getPoints().size() == 2) {
 
Danke. Warum funktioniert in diesem Fall () bei dem Lambda-Ausdruck nicht? Mit einer Variable x funktioniert es beispielsweise. Gibt es hierbei bestimmte Naming Conventions? Wird () nicht sogar beim Instanziieren benutzt, was hier ja passiert (?).

Jetzt funktionieren auf jeden Fall schon mal die Funktionen Gleis hinzufügen/entfernen und ändern der Weicheneinstellung.

Da ich den Parameter int length entfernen musste, habe ich mir jetzt eine Notlösung gebastelt:
Java: 
    private void checkLength(Track track) {
        try {
            int length = track.getStartPoint().distanceTo(track.getSwitchedTo());
        } catch (ArithmeticException e) {
            // Throw exception
        }
    }
und in der addTrack Methode:
Java: 
        if (track.getSwitchedTo() != null) {
            checkLength(track);
        }

Dies ist nötig, um einen Integer overflow zu verhindern, der durch eine zu weit entfernte Punktelage entstehen kann.
Meine Methode funktioniert so auch, ist aber nicht wirklich effizient, oder? In der distanceTo() Methode wird eine ArithmeticException geworfen, wenn ein Integer overflow stattfindet. Jetzt weise ich der Variable length einen Wert zu, der allerdings hier nie verwendet wird. Kann das auch irgendwie geschickter gemacht werden?

Geht das hier auch etwas schöner (beim Auflisten der Tracks)?
Java: 
private int length;

...

@Override
    public String toString() {
        ...
        if (switchedTo != null) {
            length = getStartPoint().distanceTo(getSwitchedTo());
        }
        if (isSwitch(this)) {
            if (switchedTo != null) {
                return "s " + getId() + " " + getStartPoint() + " -> " + endPoints + " " + length;
            } else {
                return "s " + getId() + " " + getStartPoint() + " -> " + endPoints;
            }
        } else {
            return "t " + getId() + " " + getStartPoint() + " -> " + endPoints + " " + length;
        }
    }
 
DagobertDuck hat gesagt.:
Warum funktioniert in diesem Fall () bei dem Lambda-Ausdruck nicht? Mit einer Variable x funktioniert es beispielsweise.
Zum Vergrößern anklicken....
Weil die Funktion einen Parameter erwartet und ich mich verschrieben habe.

DagobertDuck hat gesagt.:
Dies ist nötig, um einen Integer overflow zu verhindern, der durch eine zu weit entfernte Punktelage entstehen kann.
Zum Vergrößern anklicken....
Da die Punkte ja nur horizontal/vertikal angeordnet sein dürfen, frage ich mich, wie es hier zu einem Overflow kommen sollte...
 
Zum Beispiel bei einer Track (-1073741824,1) -> (1073741824,1). Damit würde ein Integer overflow zustande kommen. Die Überprüfung in der distanceTo() Methode habe ich auch schon programmiert, mir geht es jetzt nur um eine gescheite Abfrage in der addTrack Methode, da der Parameter length wegfällt und eine Switch/Track gar nicht erst erstellt werden soll, wenn der Abstand zu einen der Endpunkte zu weit ist.
 
Hab ich doch geschrieben: nimm long für die Länge, dann hast Du das Problem nicht und auf checkLength() kannst Du dann verzichten.

Dann: switchedTo sollte bei einem normalen Gleis gesetzt sein.

Dein Code verkürzt sich dann Pi mal Daumen zu:
Java: 
public String toString() {
    String len = switchedTo == null ? "" : " " + getStartPoint().distanceTo(switchedTo);
    return (isSwitch() ? "s " : "t ") + getId() + " " + getStartPoint() + " -> " + endPoints + len;
}
 
mihe7 hat gesagt.:
Hab ich doch geschrieben: nimm long für die Länge, dann hast Du das Problem nicht und auf checkLength() kannst Du dann verzichten.
Zum Vergrößern anklicken....
Das tut es natürlich auch... Danke!

mihe7 hat gesagt.:
Dein Code verkürzt sich dann Pi mal Daumen zu:
Java: 
public String toString() {
String len = switchedTo == null ? "" : " " + getStartPoint().distanceTo(switchedTo);
return (isSwitch() ? "s " : "t ") + getId() + " " + getStartPoint() + " -> " + endPoints + len;
}
Zum Vergrößern anklicken....

Das ist ja genial, vielen Dank!
 
mihe7 hat gesagt.:
Java: 
List<Track> connections = edges.computeIfAbsent(track.getStartPoint(), () -> new ArrayList<>());

if (connections.isEmpty() || connections.get(0).getPoints().size() == 2) {
    ...
} else {
    // Throw exception
}
Zum Vergrößern anklicken....
@mihe7 Leider funktioniert das noch nicht so ganz. Zum Beispiel beim Ablauf
Code: 
        add track (1,1) -> (5,1)
        1
        add switch (5,1) -> (8,1),(5,3)
        2
        add track (10,1) -> (8,1)
        3
        add switch (10,-3) -> (10,1),(12,-3)
        4
        add track (10,-3) -> (1,-3)
        Error, only one other track can be connected at any one point on a track

Hier sollte allerdings keine Fehlermeldung ausgegeben werden, da dies ein valides Gleis bzw. Netzwerk wäre. Was ist hier falsch?
 
abc66 hat gesagt.:
Täusche ich mich, oder gibt es in letzter Zeit exorbitant viele Fragen zu Graphen und Bahnhöfen?
Zum Vergrößern anklicken....
Das Semester nähert sich dem Ende 🙂

DagobertDuck hat gesagt.:
Eine Weiche ist eine Track, das ist richtig, aber inwiefern löst das mein Problem?
Zum Vergrößern anklicken....
Ich bin wieder soweit, dass ich der Meinung bin, dass an jedem Punkt der Map einfach nur zwei Tracks in der Liste stehen dürfen, sozusagen "ankommender Track" - "ausgehender Track".
 
mihe7 hat gesagt.:
Ich bin wieder soweit, dass ich der Meinung bin, dass an jedem Punkt der Map einfach nur zwei Tracks in der Liste stehen dürfen, sozusagen "ankommender Track" - "ausgehender Track".
Zum Vergrößern anklicken....
Das soll auch so sein. Muss es dann nicht einfach
Java: 
if (connections.isEmpty() || connections.get(0).getPoints().size() != 2) {
heißen, oder vertue ich mich hier?
 
Das macht natürlich Sinn. Danke! Noch eine kurze Frage: hast du eine Idee, wie ich prüfen kann, ob jede Track zu einem Punkt geswitched ist? Bei normalen Gleisen ist dies ja bereits immer der Fall. Bei Weichen allerdings nicht.
Meine Idee ist
Java: 
tracks.values().forEach(x -> (x.getSwitchedTo() != null) ? throw new ... ("position of switches not set")));
So funktioniert es nur leider nicht. Bisher habe ich noch nicht viel mit Lambda-Expressions und Collection/Stream-forEach gearbeitet.
 
Wenn es eine RuntimeException ist, dann sollte
Java: 
tracks.values().stream().findAny(x -> x.getSwitchedTo() == null).ifPresent(x -> throw new ...);
funktionieren, sonst
Java: 
if (tracks.values().stream().findAny(x -> x.getSwitchedTo() == null).isPresent()) {
    throw ...
}
 
Super, danke für die schnelle Antwort. findAny() scheint hier aber nicht zu funktionieren, oder? Dabei wird in meiner IDE die Fehlermeldung Cannot resolve method 'getSwitchedTo()' angezeigt.
 
Guten Abend,

das Projekt neigt sich langsam dem Ende zu und ich habe noch Schwierigkeiten mit zwei essentiellen Funktionen.

Die erste Funktion ist es, einen Zug auf ein Gleis zu setzen. Dabei wird immer der ganze Zug komplett auf das Gleis gesetzt. Beim Aufsetzen muss ein Richtungsvektor angegeben werden. Dieser gibt die initiale Fahrrichtung des Zuges an. Der Richtungsvektor entspricht dem Richtungsvektor des Gleises oder ist genau der entgegensetze Vektor. Beim Aufgleisen muss beachtet werden, dass die benutzten Gleise noch frei sind, d.h. kein anderer Zug dort steht und es dort überhaupt ein Gleis gibt. Dabei spielt natürlich auch die Länge eines Zuges eine Rolle. Falls der Zug auf eine Weiche gesetzt werden soll, muss zuerst geprüft werden, ob die Gleisweichenstellung dementsprechend eingestellt ist. Falls dies nicht der Fall ist, soll eine Fehlermeldung ausgegeben werden. Falls Gleisweichen auf denen ein Zug bereits steht, geschaltet werden, entgleist der daraufstehende Zug.

Hier ist meine bisherige Methode:
Java: 
    /*
    TODO:
         - Check if there is even a track at the point <point>.
         - If it is a switch at point <point> then check if it's switched to this track.
         - Check if no other train is already on the required track(s) - note the length of the train
         - Check if directionVector fits with direction of track
    */
    public void putTrain(Train train, Point point, Point directionVector) throws LogicException {
        ...
        long trainLength = train.getLength();

    }

Wie sollte ich am besten alle Züge, die aufgegleist sind, speichern? Für den step <speed> Befehl, der alle Züge um n-Einheiten fahren lässt, ist es wichtig zu wissen, in welche Richtung der Zug fahren soll (Richtungsvektor) und auf welchem Punkt sich der Zugkopf (vorderster Wagen) gerade befindet. Meine ursprüngliche Idee war es, die aufgegleisten Züge in einer Map<Point, Train> zu speichern, aber woher weiß man dann beim step Befehl in welche Richtung er fahren soll? Des Weiteren weiß ich noch nicht so richtig wie ich den angegeben Richtungsvektor, der durch eine x- und y-Koordinate angegeben wird, auszuwerten habe. Macht es Sinn ihn zu normieren?
Ich hoffe, dass mir hierbei jemand helfen könnte.

Viele Grüße
 
Eine Möglichkeit ist es über das Kreuzprodukt zu berechnen, zumindest klappt es bei mir auf die Weise, wenn ich über die Edges gehe
Java: 
    public boolean isPointOnEdge(int xCoordinateToCheck, int yCoordinateToCheck, int lengthOfTrain,
            int xDirectionVector, int yDirectionVector) {
        for (int i = 0; i < allTracks.size(); i++) {
            if (allTracks.get(i) instanceof NormalTrack) {
                int xCoordStart = allTracks.get(i).getStartXCoordiante();
                int yCoordStart = allTracks.get(i).getStartYCoordiante();
                int xCoordEnd = allTracks.get(i).getEndXCoordiante();
                int yCoordEnd = allTracks.get(i).getEndYCoordiante();

                int dxc = xCoordinateToCheck - xCoordStart;
                int dyc = yCoordinateToCheck - yCoordStart;

                int dxl = xCoordEnd - xCoordStart;
                int dyl = yCoordEnd - yCoordStart;

                int cross = dxc * dyl - dyc * dxl;
                if (cross == 0) {
                    if (Math.abs(dxl) >= Math.abs(dyl)) {
                        if (dxl > 0) {
                            ...
                           
                            }
                        }
 
Das hilft hier nicht weiter, da wir hier ein anderes Modell haben. Konkret brauchen wir eine Methode der Form
Java: 
/** findet den Track, der ein Gleis enthält, auf dem Punkt p liegt. 
  * @returns Track oder null, falls kein Track gefunden wurde.
  */
public Track findTrack(Point p) {
}
Ist jetzt nicht sooo schwer.
 
@mihe7 Ich habe folgende Idee:
Jede Track durchgehen und überprüfen, ob die Distanz vom Startpunkt zum angegebenen Punkt + die Distanz vom Endpunkt zum angegeben Punkt gleich die Distanz vom Startpunkt zum Endpunkt ist. Sobald eine Track mit dieser Eigenschaft gefunden wird, wird sie returned.

Also irgendwie so:
Java: 
if (getStartPoint().distanceTo(point) + getEndPoints.get(0).distanceTo(point) == getStartPoint.distanceTo(getEndPoint.get(0))) {
    // Der Punkt liegt auf dem Gleis
    return track;
}
// Der Punkt liegt auf keinem Gleis
return false;

Das ganze dann in einer for-Schleife und beide Endpunkte beachten. Ist dieser Ansatz sinnvoll, oder geht es besser?
 
Einer weitere Idee wäre: Für jede Track wird geschaut, ob die x-Koordinate mit der x-Koordinate von dem angegebenen Punkt übereinstimmt. Falls ja, dann: prüfen, ob die y-Koordinate des Punktes zwischen den beiden y-Punkten des Gleises liegt; und umgekehrt. Die Laufzeit des Algorithmus wäre O(n) für die Anzahl der Tracks.
 
Du kannst dabei ausnutzen, dass Du Track-Objekte hast, die Methoden anbieten können... 😉

EDIT: macht den Umgang mit Weichen einfacher.
 
Nur wann weiß ich, ob die Track horizontal oder vertikal ist, damit ich entweder die x- oder die y-Koordinate prüfen kann? Muss ich vorher prüfen, ob die x- bzw y-Koordinaten gleich sind -> horizontal / vertikal? Sollte ich mir dafür am besten eine Methode in der Klasse Track schreiben (nur mit welchem Rückgabetyp)?
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Funktionen Plotter - Klassen/Methoden/Funktionen
Antworten: 13
Rekursive Funktionen in imperative Funktionen umwandeln
Antworten: 2
Funktionen/Methoden/Variablen includieren? :)
Antworten: 4
Sortieren und Filtern von Funktionen/Methoden
Antworten: 4
Methoden Funktionen
Antworten: 6

Zurück
Oben