Zeichenbrett für Rechtecke mit Hindernissen

[Floppy]

Erstmal ein "Hallo" in die Runde

Mein Ziel ist es, eine Klasse zu schaffen, die erstmal als Zeichenbrett für Rechtecke dienen soll. Diese Rechtecke werden per Maus "aufgezogen" (wie auf dem Windows-Desktop mit gedrückter Maustaste, man sieht also einen Rahmen), läßt man die Taste los, erscheint das Rechteck. Auf der Fläche soll man bis zu 10 Rechtecke zeichnen können.
So weit bin ich nun auch schon gekommen und es klappt wunderbar.
Nun würde ich gerne dazu übergehen, diese Rechtecke in einem Vektor zu speichern. Leider bin ich damit ein bisschen überfordert.
Hier mal mein Code:

public class ZeichenBrett extends Frame implements MouseListener, MouseMotionListener {
	
    int counter = 0;
    int max_images = 10;
    int points_topleft[][] = new int[max_images][2];
    int points_bottomright[][] = new int[max_images][2];
    int points_dragg[][] = new int[1][2];
    int data[][] = new int[max_images][4];
    boolean dragged;
	
    public ZeichenBrett() {
	addMouseListener(this);
	addMouseMotionListener(this);
	addWindowListener(new WindowClosingAdapter());
	setVisible(true);
    }
	
    public void mousePressed(MouseEvent e) {
	if ( counter < max_images ) {
	    points_topleft[counter][0] = e.getX();
	    points_topleft[counter][1] = e.getY();
	}
    }
	
    public void mouseDragged(MouseEvent e) {
	if ( counter < max_images ) {
	    points_dragg[0][0] = e.getX();
	    points_dragg[0][1] = e.getY();
	    dragged = true;
	    repaint();
	}
    }
	
    public void mouseReleased(MouseEvent e) {
	if ( counter < max_images ) {
	    points_bottomright[counter][0] = e.getX();
	    points_bottomright[counter][1] = e.getY();
	    ++counter;
	    repaint();
	}
    }
	
    public void paint(Graphics g) {
	if ( counter <= max_images ) {
	    if ( dragged ) {
		int width_dragg = Math.abs(points_dragg[0][0] - points_topleft[counter][0]);
		int height_dragg = Math.abs(points_dragg[0][1] - points_topleft[counter][1]);
		g.setColor(Color.GREEN);
		g.drawRect(points_topleft[counter][0], points_topleft[counter][1], width_dragg, height_dragg);
		dragged = false;
	    }
	    for ( int i = 0; i < counter; ++i ) {
		int width = Math.abs(points_bottomright[i][0] - points_topleft[i][0]);
		int height = Math.abs(points_bottomright[i][1] - points_topleft[i][1]);
		g.setColor(Color.BLUE);					
		g.drawRect(points_topleft[i][0], points_topleft[i][1], width, height);
		data[i][0] = points_topleft[i][0];
		data[i][1] = points_topleft[i][1];
		data[i][2] = width;
		data[i][3] = height;
	    }
	}
    }
	
    public void mouseClicked(MouseEvent e) { }
    public void mouseEntered(MouseEvent e) { }
    public void mouseExited(MouseEvent e) { }
    public void mouseMoved(MouseEvent e) { }

    public static void main (String [] args) {
		ZeichenBrett test = new ZeichenBrett();
		test.setTitle("FotoView");
		test.setSize(500, 350);
    }
}

class WindowClosingAdapter extends WindowAdapter {
	public void windowClosing(WindowEvent e) {
		System.exit(0);
	}
}

Meine erste Idee war, die 4 relevanten Daten pro Rechteck (Breite, Höhe, X/Y-Wert der linken oberen Ecke) in einem mehrdimensionalen Array (siehen oben, Array data) zu speichern und das dann in den Vektor zu packen.
Hört sich gut an, bekomme es aber irgendwie nicht umgesetzt...

Am Besten wäre es wohl, die Erstellung der Rechtecke in eine eigene Klasse zu packen und diese dann im Vektor zu speichern. Aber auch da hakt es irgendwie in meinen Gedanken (ist auch schon spät).

Was mich noch beschäftigt ist folgendes: mir war es nicht möglich, die Zeichenfläche mit einem JFrame umzusetzen, da die Rechtecke beim verändern des Fensters regelmäßig verschwunden sind. Mit dem normalen Frame klappt es ohne Probleme. Was könnte ich bei dem JFrame falsch gemacht haben, oder gibt es immer Probleme, wenn man direkt auf ein JFrame zeichnen will...?

Wow, erster Beitrag und dann gleich so lang. Hoffe, dass irgendjemand ein bisschen durchsteigt und mir helfen kann. Bin für jeden Tipp dankbar :toll:

 

[bummerland]

Erstmal hallo und herzlich willkommen im Forum!

Ich würde nicht direkt auf einem Frame zeichnen, sondern auf einer JComponent oder einem JPanel. Damit ist dein Code besser wiederverwendbar. Das sollte auch dein Problem mit den verschwundenen Rechtecken beheben.
Dann würde ich eine Klasse Rechteck anlegen, die die Koordinaten als Membervariablen hat und die Methode paint(Graphics g) um sich selbst zu zeichnen. Deine Rechteckobjekte kannst du dann in einem Vector speichern. Beim zeichnen der Fläche gehst du nur deinen Vector durch und zeichnest jedes Rechteck mit rechteck.paint(g).
Hoffe, das konnte einigermassen helfen. :autsch:

 

[KSG9|sebastian]

mach das was becstift sagt

ne eigene Klasse Rechteck mit den Eigenschaften, dann kannst du die Rechtecke in nem Vector, oder was ich dir eher empfehlen würde, ein einem Rechteck-Array speicherst. Das geht natürlich nur, wenn du max. 10 Rechtecke hast.

Rechteck[] rechtecke = new Rechteck[10]


Und ja, ich würde am besten in ein JPanel oder so zeichnen..

 

[Guest]

Sorry, dass ich mich erst jetzt wieder melde, aber ich musste 4 Klausuren schreiben

Bin jetzt dabei, das Zeichnen der Rechtecke über eine eigene Klasse zu machen. Leider klappt schon eine erste, einfach Version nicht:

public class Page extends Frame {
	
	public Page() {
		super("Test");
		
		Rect re = new Rect();
		setVisible(true);
	}

	public static void main(String[] args) {
		Page tester = new Page();
		tester.setSize(500, 350);
	}
}


class Rect {
	
	public Rect() {
		System.out.println("Konstruktor");
	}
	
	public void paint(Graphics g) {
		g.setColor(Color.GREEN);
		g.fillRect(5, 5, 100, 100);
	}
}

Frage: wieso zeichnet er das Redhteck nicht? Packe ich die paint Methode in die Klasse Page, funktioniert alles. Lasse ich sie aber in der Klasse Rect, klappt es nicht...?

 

[Floppy]

Ups, jetzt hab ich die Antwort als Gast geschrieben, wusste gar nicht, dass das hier geht

 

[Beni]

Weil die paint-Methode des Rechteckes nie aufgerufen wird.
Beim zeichnen werden normalerweise nur die paint-Methoden des Frames und seiner Component's aufgerufen. Du musst da selbst noch eine "Verzweigung" einbauen:

public class Page extends Frame {
   private Rect rect;   

   public Page() {
      super("Test");
      
      rect = new Rect();
      setVisible(true);
   }

   public static void main(String[] args) {
      Page tester = new Page();
      tester.setSize(500, 350);
   }

   public void paint( Graphics g ){
     g.setColor( Color.WHITE );
     g.fillRect( 0, 0, getWidth(), getHeight() );

     if( rect != null ){
        rect.paint( g );   // <<<<< hier muss der Paint-Aufruf weitergeleitet werden.
     }
   }
}


class Rect {
   
   public Rect() {
      System.out.println("Konstruktor");
   }
   
   public void paint(Graphics g) {
      g.setColor(Color.GREEN);
      g.fillRect(5, 5, 100, 100);
   }
}

 

[Isaac]

Wenn du dir das Programm nimmst das ich für Benni gestern geschrieben habe

und die Zeile

graphObj.add(new Line2D.Double(iLineStartX, iLineStartY, iLineEndX, iLineEndY));

in der paint Methode ersetzt durch

if(iLineEndX < iLineStartX)
            {
                int buff    = iLineEndX;
                iLineEndX   = iLineStartX;
                iLineStartX = buff;
            }
            if(iLineEndY < iLineStartY)
            {
                int buff    = iLineEndY;
                iLineEndY   = iLineStartY;
                iLineStartY = buff;
            }
            graphObj.add(new Rectangle2D.Double(iLineStartX, iLineStartY, iLineEndX - iLineStartX , iLineEndY - iLineStartY));

Dann zeichnet das Programm statt Linien Rechtecke.

Hier das Programm (ganz unten das, mit dem Bild im Posting):

Linien zeichen

 

[Floppy]

@ Beni
Danke, klappt :toll:

Aber wieso muss ich das so machen? Dachte, dass die paint-Methode automatisch aufgerufen wird... Daher sollte sie beim erzeugen der Instanz rect von Rect doch eigentlich auch aufgerufen werden, oder?


@ Isaac
Danke, aber ich will ja selber vorwärts kommen und nicht nur abschreiben

 

[Beni]

dass die paint-Methode automatisch aufgerufen wird

Jede Methode muss von irgendjemandem aufgerufen werden.

Bei allen Components wird die paint-Methode von der *Parent-Component aufgerufen. Das geht solange hoch, bis ein Window kommt.
Wenn man nun eine paint-Methode in einer Component schreibt, überschreibt man das Original (ein wichtiges Prinzip von Objekten...), und deshalb wird die eigene, selbstgeschriebene paint-Methode aufgerufen.


Aber dein Rect ist ja keine Component, und wird deshalb auch nicht Teil des Component-Baumes werden. Daher wird seine paint-Methode sicher nicht "automatisch" aufgerufen.

( * das ist vereinfacht gesagt, aber für dieses Problem muss man nicht mehr wissen )

 

[Floppy]

Wieder was gelernt, danke

Bin jetzt so weit, dass ich mit jedem Mouseclick ein neues Quadrat an der Stelle erzeuge, wo sich die Maus gerade befindet. Des Weiteren wird das Quadrat in einem Vector abgelegt.
Problem: man sieht immer nur ein Rechteck, und zwar das letzte.
Denke, dass es daran liegt, dass ich den Vector ja nicht ausgebe, sondern immer nur das aktuelle Quadrat zeichne.
Mein Frage wäre nun, wie und wo ich den Vector ausgeben soll, so dass ich alle Quadrate sehe und nicht nur das aktuelle (reicht es überhaupt, immer die Klasse in den Vexot zu packen oder speichert er da gar nicht alle nötigen Werte, die er zum Zeichnen braucht?).

ublic class Page extends Frame implements MouseListener {
	
	private Rect rect;
	private int x, y;
	private int counter = 0;
	Vector v = new Vector();
	
	public Page() {
		super("Test");
		addMouseListener(this);
		addWindowListener(new WindowClosingAdapter());
		setVisible(true);
	}
	
	public void paint( Graphics g ) {
		if ( rect != null ) {
			rect.paint(g);
		}
	}
	
	public void mousePressed(MouseEvent e) {
			x = e.getX();
			y = e.getY();
			rect = new Rect(x, y);
			v.addElement(rect);
			++counter;
			repaint();
	}
	
	public void mouseReleased(MouseEvent e) { }
	public void mouseClicked(MouseEvent e) { }
	public void mouseEntered(MouseEvent e) { }
	public void mouseExited(MouseEvent e) { }
	public void mouseMoved(MouseEvent e) { }
	
	public static void main(String[] args) {
		Page tester = new Page();
		tester.setSize(500, 350);
	}
}


class Rect {
	
	private int x, y;
	
	public Rect(int x, int y) {
		System.out.println("Konstruktor");
		this.x = x;
		this.y = y;
	}
	
	public void paint(Graphics g) {
		g.setColor(Color.GREEN);
		g.fillRect(x, y, 100, 100);
	}
}

 

[Roar]

nee das geht so nicht. wieso speicherst du überhaupt die variablen rect, x und y in der Klasse? sollten das nicht besser lokale variablen sein? dann malst du nur das Rechteck was du als letztes gemalt hast, aber nicht die rechtecke die du vorher im Vector abgespeichert hast. du musst dir jedes rechteck aus dem vector holen und malen.

 

[Floppy]

du musst dir jedes rechteck aus dem vector holen und malen.

Und genau da liegt mein Problem :shock:

 

[Roar]

gehts vielleicht was konkreter? wo is da n problem? Vector.get(index i) um das objekt rauszuholen

 

[Floppy]

Hab es hinbekommen:

public void paint( Graphics g ) {
	Enumeration en = v.elements();
	while(en.hasMoreElements()) {
		((Rect)en.nextElement()).paint(g);
	}
}

Das war mein Problem

x und y habe ich jetzt aus der Klasse rausgenommen und speichere sie nur noch lokal in der Methode mousePressed.
Rect wird jetzt auch erst in mousePressed erstellt.
Danke

 

[Floppy]

So, hier jetzt die "fertige" Version:

import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class Page extends Frame implements MouseListener, MouseMotionListener {
	
	private Rect rect;
	private int counter = 0;
	private int max_rects = 10;
	Vector v = new Vector();
	
	public Page() {
		super("Rechtecke");
		addMouseListener(this);
		addMouseMotionListener(this);
		addWindowListener(new WindowClosingAdapter());
		setVisible(true);
	}
	
	public void paint( Graphics g ) {
		Enumeration en = v.elements();
		while ( en.hasMoreElements() ) {
			( (Rect)en.nextElement() ).paint(g);
		}
	}
	
	public void mousePressed(MouseEvent e) {
		if ( counter < max_rects ) {
			int x = e.getX();
			int y = e.getY();
			rect = new Rect(x, y);
			v.addElement(rect);
		}
	}
	
	public void mouseDragged(MouseEvent e) {
		if ( counter < max_rects ) {
			rect.setDraggXY(e.getX(), e.getY(), true);
			repaint();
		}
	}
	
	public void mouseReleased(MouseEvent e) {
		if ( counter < max_rects ) {
			rect.setEndXY(e.getX(), e.getY());
			++counter;
			repaint();
		}
	}
	
	public void mouseClicked(MouseEvent e) { }
	public void mouseEntered(MouseEvent e) { }
	public void mouseExited(MouseEvent e) { }
	public void mouseMoved(MouseEvent e) { }
	
	public static void main(String[] args) {
		Page tester = new Page();
		tester.setSize(500, 350);
	}
}


class Rect {
	
	private int startX, startY;
	private int draggX, draggY;
	private int endX, endY;
	boolean dragged;
	
	public Rect(int x, int y) {
		startX = x;
		startY = y;
	}
	
	public void setDraggXY(int x, int y, boolean dragged) {
		draggX = x;
		draggY = y;
		this.dragged = dragged;
	}
	
	public void setEndXY(int x, int y) {
		endX = x;
		endY = y;
	}
	
	public void paint(Graphics g) {
		if ( dragged ) {
			int width = Math.abs(draggX - startX);
			int height = Math.abs(draggY - startY);
			g.setColor(Color.GREEN);
			g.drawRect(startX, startY, width, height);
			dragged = false;
		} else {
			int width =  Math.abs(endX - startX);
			int height =  Math.abs(endY - startY);
			g.setColor(Color.BLUE);
			g.drawRect(startX, startY, width, height);
		}
	}
}


class WindowClosingAdapter extends WindowAdapter {
	public void windowClosing(WindowEvent e) {
		System.exit(0);
	}
}

Gibt es Dinge, die man noch eleganter lösen kann?

 

[Floppy]

Habe mir nun folgendes gedacht:
nach jedem Rechteck, dass ich aufgezogen habe, suche ich über FileDialog ein Bild aus, dieses wird dann genau in das entsprechende Recheck/Quadrat eingepasst.
Problem was ich dabei habe: ich kann ein Bild nur in einem Frame etc. laden, nicht aber in meine Klasse Rect.
Eine geladenes Bild füllt also immer das ganze Fenster.

Ist das was ich vorhabe überhaupt möglich?

 

[Beni]

ich kann ein Bild nur in einem Frame etc. laden,

???:L Aber die Klasse ImageIO kennst du? :wink:

Dann besitzt du ein Image-Objekt, und kannst es mit Graphics#drawImage( ... ) zeichnen. Diesen Bild-zeichnen-Aufruf kommt halt dorthin, wo auch die Rect's zeichnen.

 

[Floppy]

Hab es jetzt hinbekommen, wußte nicht, dass man bei drawImage auch die Größe des Bildes angeben kann

Allerdings habe ich es jetzt ganz ohne ImageIO gelöst...