GUI Node Programmierung! Brauche Hilfe

[judas1980]

Hey Leute ich benötige unbedingt Hilfe bei der folgenden Aufgabe und eigentlich bis gestern :-) Habe vergessen die Aufgabe abzugeben und muss die bis Sonntag wegschicken, sonst war ein halbes Jahr lernen umsonst:

Bitte um Hilfe!!!

Es soll eine GUI programmiert werden, mit MVC:

Um von Anfang an eine bessere Strukturierung des Programms zu erzielen, programmieren Sie eine Node-Klasse, die einen Knoten innerhalb einer Graphstruktur darstellen soll. Ein Node-Objekt soll als Eigenschaften eine id (eindeutige Bezeichnung), eine Position (x-, y-Koordinaten), eine Größe und eine Farbe (Color-Objekt) besitzen. Die Node-Klasse soll mindestens zwei Konstruktoren anbieten. Eine, die die Position und die Größe des Knotens als Argument bekommt und eine, die nach Eingabe eines Wertebereichs die Position mit Hilfe eines Random-Objekts zufällig erzeugt.

Die wichtigste Methode in dieser Klasse, weil für die Ereignisbehandlung notwendig ist, ist die inNode-Methode, die nach Eingabe einer Punktposition entscheidet, ob sich der Punkt innerhalb der Knotenfläche befindet oder nicht.

public boolean inNode( int x, int y )

oder

public boolean inNode( Point p )

c) Als Zweites programmieren Sie eine Graph-Klasse.

Diese Klasse soll Graph-Objekte darstellen. Ein Graph-Objekt besteht aus einer Menge von Knoten und einer Menge von Verbindungen zwischen den Knoten (Kanten). Die Verbindungen zwischen den Knoten können mit Hilfe einer Adjazenzmatrix oder einer Adjazenzliste implementiert werden (siehe Vorlesungsfolien). Die Graph-Klasse soll mindestens einen Konstruktor anbieten, der bei Eingabe einer Knotenzahl und eines Wertebereichs für die Position der Knoten des Graphs alle Knoten mit zufälligen Positionen und zufälligen Verbindungen zwischen den Knoten erzeugt.

d) Schreiben Sie von Anfang an eine print-Methode, die die Verbindungen zwischen den Knoten in Textform ausgibt und eine connect-Methode, die neue Verbindungen zwischen zwei eingegebenen Knoten ermöglicht.

e) Schreiben Sie eine paint-Methode, damit das Graph-Objekt sich selbst bei Eingabe eines graphischen Kontexts (Graphics-Objekt) auf beliebige Behälter-Objekte zeichnen kann.

f) Programmieren Sie eine GraphPicture-Klasse als Unterklasse der JPanel-Klasse, die in Ihrem Konstruktor ein Graph-Objekt als Parameter bekommt und dieses Graph-Objekt entsprechend zeigt.

g) Innerhalb der GraphPicture-Klasse sollen die MouseListener- und die MouseMotionListener-Interfaces implementiert werden (siehe Vorlesungsbeispiel), so dass möglichst einfach die Positionen der Knoten innerhalb des Graph-Objekts verändert werden können, und neue Verbindungen zwischen den Knoten mit einfachen Maus-Klicks hergestellt werden können.

h) Zum Schluss programmieren Sie eine Fenster-Klasse, die das Graph-Objekt auf dem Bildschirm sichtbar macht.

Bin für jedes Codestück dankbar!

[judas1980]

hier meine ersten ausführungen zu .

ich brauche dabei hilfe bei der methode inNode und bei dem zweiten Konstruktor (random)

import java.awt.Color;

/*

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

/**

*

* @author Eric

*/

public class Node {

int id;

int x, y;

int size;

Color color = Color.BLUE;

public Node(int x, int y, int size){

this.x=x;

this.y=y;

this.size = size;

}

public Node(){

}

public boolean inNode(int x, int y){

}

}

[judas1980]

so hab hier noch mal was für die graph klasse geschrieben, aber da habe ich echt keine ahnung, ob das irgendwie stimmt. ich habe es einfach nach meinem besten wissen gemacht.

import java.awt.Color;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.Vector;

public class Graph{

ArrayList<Node> adjList = new ArrayList<Node>();

ArrayList<Edge> edges = new ArrayList<Edge>();

int nextId = 0;

// für BFS

Vector<Node> queue = new Vector<Node>();

Node startNode;

public void initBFS(){

for( Node node : adjList ){

node.color = Color.WHITE;

node.dist = Integer.MAX_VALUE;

node.pred = null;

}

this.startNode = adjList.get(0);

for ( Edge edge : edges ){

edge.setMarked(false);

}

}

public void BFS(){

Node v_node, d_node = null;

this.startNode.setColor(Color.GRAY);

this.startNode.dist = 0;

this.queue.add( startNode );

while( !queue.isEmpty() ){

v_node = queue.firstElement();

Iterator iter = v_node.neighbours.iterator();

while ( iter.hasNext() ){

d_node = (Node) iter.next();

if ( d_node.color == Color.WHITE ){

d_node.setColor(Color.GRAY);

d_node.dist = v_node.dist+1;

d_node.pred = v_node;

queue.add(d_node);

}

}

queue.remove(0);

v_node.setColor(Color.BLACK);

}

[Schiller256]

Dein Random Problem kannst du mit Math.random() angehen. Hier bekommst du eine Zahl zwischen 0 und 1 und kannst damit dann weiter arbeiten.

Deine Seminararbeit wird dir hier aber keiner machen. Da hilft es nur die Vorlesung im nächsten Semester nochmal besuchen.

[judas1980]

dachtest du vielleicht ich kenne die mathrandom funktion nicht???

es soll auch niemand meine seminararbeit machen, sondern mir tipps für die eingestellten codefragmente geben!

[ksg9-sebastian]

Erster Tipp: Code-Tags !

die sehen so aus und dann ist der Code ganz toll formatiert

Dann zu deiner Seminararbeit: Die Methode inNode(int x, int y) soll berechnen ob der übergeben Punkt in der Node liegt. Die Node ist definiert mit x, y als Koordinate und size als Größe. Somit würde eine Node mit x=10, y=10, size=5 im Koord.system bei 10/10 einen "Eckpunkt" haben und jeweils 5 hoch und 5 breit sein. Somit würde die Methode ungefähr so aussehen:

public boolean inNode(int pX, int pY){

   boolean inNode

   xEnde = x + size;

   yEnde = y + size;

   boolean xInside = false;

   boolean yInside = false;


   xInside = pX >= this.x && pX <= xEnde;

   yInside = pY >= this.y && pY <= yEnde;


  return xInside && yInside;

}

Dann zum Konstruktor..folgende Parameter sollen übergeben werden: - Wertebereich für x-Position - Wertebereich für y-Position - Wertebereich für Größe So hab ich's zumindest verstanden D.h. du erzeugst die Parameter zwischen den beiden gegebenen Zahlen. Bsp: x-Position soll zwischen 10 und 20 sein. D.h. du erzeugst ne Zufallszahl zwischen 10 und 20. Das geht z.B. mit Math.random() welcher eine Zahl zwischen 0 und 1 (exclusive) erzeugt. Um auf den Wertebereich zu kommen musst du die erzeugte Zufallszahl mit der Differens (xEnd, xStart) multiplizieren und dann xStart addieren. xStart - 10 xEnd - 20 Differenz d = 10 Zufallszahl z = 0.4 z = z * 10 -> 4 z + xStart = 14 Somit wäre x = 14. Analog kannst du die anderen Zahlen auch erzeugen.

public Node(int xStart, int xEnd, int yStart, int yEnd, int sizeStart, int sizeEnd){

    this.x = (Math.random() * Math.abs(xEnd - xStart)) + xStart;

    this.y = (Math.random() * Math.abs(yEnd - yStart)) + yStart;

    this.size = (Math.random() * Math.abs(sizeEnd - sizeStart)) + sizeStart;

}

Code musstn och entsprechend korrigieren wegen Casts u.s.w.