# rekursive Grafik



## Topblocker (18. Jan 2011)

Hallo!

Wir wollen in der Schule jetzt damit beginnen, grafische Objekte in Java zu erstellen. Wir haben direkt mal die Aufgabe gekriegt, uns im Internet über die Grundlagen dafür klar zu werden und direkt mal ein Programm zu schreiben, das eine Grafik rekursiv aufbaut.
Ausgewählt hab ich dafür folgendes, weil ich dachte es wäre für den Anfang nicht so schwer:
man beginnt mit einem Rechteck, hängt an dieses ein Dreieck, daran wieder ein Rechteck usw., also etwa so:




Nach einiger Arbeit bin ich zu folgendem Ansatz gekommen:


```
import java.awt.*;
import java.applet.*;

public class combine extends Applet // Anfang bei 200|200
{
    public int[] Dx1;
    public int[] Dy1;
    public int[] Dx2;
    public int[] Dy2;
    
    public int[] Rx1;
    public int[] Ry1;
    public int[] Rx2;
    public int[] Ry2;
    
    public int c=0; // recCounter
    public boolean Fortsetzen=true;
    
    public combine()
    {
        this.Dx1 = new int[100];
        this.Dy1 = new int[100];
        this.Dx2 = new int[100];
        this.Dy2 = new int[100];
        
        this.Rx1 = new int[100];
        this.Ry1 = new int[100];
        this.Rx2 = new int[100];
        this.Ry2 = new int[100];
        
        for(int i=0; i<=10; i++){
            Rx1[i] = 200;
            Ry1[i] = 200;
            Rx2[i] = 200;
            Ry2[i] = 200;
        }
    }
    
    public void init(Graphics g){
        if(Fortsetzen == true){
            paint(g);
        }
    }
    
    public void paint(Graphics g)
    {
        if(c == 2){
            Fortsetzen = false;
        }
        
            c++;
            
            Rechteck(g,Rx1[c],Ry1[c],Rx2[c],Ry2[c]);
            
            /* Dreieck --> Ausgangspunkte an die obere rechte Ecke des Rechtecks */
            Dx2[c] = Rx2[c] + 30;
            Dy2[c] = Ry2[c];
            Dx1[c] = Dx2[c] + 30;
            Dy1[c] = Dy2[c];
            Dreieck(g,Dx1[c],Dy1[c],Dx2[c],Dy2[c]);
            
            /* Rechteck */
            //Rx1[c+1] = Dx1[c];
            //Ry1[c+1] = Dy1[c];
            //Rx2[c+1] = Rx1[c+1] + 30;
            //Ry2[c+1] = Ry1[c+1];
            
            init();
    }
    
    public void Dreieck(Graphics g, int Dx1, int Dy1, int Dx2, int Dy2)
    {
        g.setColor(Color.blue);
        g.drawLine(Dx1,Dy1,Dx2,Dy2); // Strecke BA
        g.drawLine(Dx1,Dy1,Dx2,Dy2+30); // Strecke BC
        g.drawLine(Dx1-30,Dy1,Dx2,Dy2+30); // Strecke AC
    }
    
    public void Rechteck(Graphics g, int Rx1, int Ry1, int Rx2, int Ry2)
    {
        g.setColor(Color.red);
        g.drawLine(Rx1,Ry1,Rx2+30,Ry2); // Strecke AB (200,200,230,200)
        g.drawLine(Rx1+30,Ry1,Rx2+30,Ry2+30); // Strecke BC (230,200,230,230)
        g.drawLine(Rx1+30,Ry1+30,Rx2,Ry2+30); // Strecke CB (230,230,200,230)
        g.drawLine(Rx1,Ry1+30,Rx2,Ry2); // Strecke DA (200,230,200,200)
    }
}
```

Ich bin in Graphics und Rekursion noch ein Anfänger, deswegen bräuchte ich ein wenig Hilfe. Mit dem obigen Code wird erstmal ein Quadrat und ein Dreieck erzeugt, so wie es sein soll. Wenn ich nun die Kommentare bei *Rechteck* lösche, sollten die Koordinaten des *nächsten* Rechtecks angepasst werden, aber stattdessen wird das erste völlig deformiert, was ich nicht so ganz verstehe.

Und das nächste wäre dann, die Koordinaten der Folgeglieder richtig zu bestimmen, denn so ganz stimmt das noch nicht, so hätte ich viele Drei- und Rechtecke in einer Reihe. Ich bräuchte etwas, womit ich eine Senkrechte auf der jeweils rechten Seite erzeugen kann (beim Dreieck und beim Quadrat ist es beide Male die Strecke BC), da ja das Objekt unter einem gewissen Winkel geneigt sein soll.

Das ganze ist ziemlich komplex, ich hoffe dass da jemand durchblickt und mir helfen kann, danke schonmal

Gruß,
Topblocker


----------



## Marco13 (18. Jan 2011)

Wenn es komplex ist, solltest du was dagegen unternehmen. Ein wichtiges Ziel bei der Programmierung ganz allgemein ist es, Komplexität handhabbar zu machen. 

Wenn du mal in der paint, so gegen Ende,

```
System.out.println("Rechteck "+c+" war "+Rx1[c]+" "+Ry1[c]+" "+Rx2[c]+" "+Ry2[c]);
            System.out.println("Rechteck "+(c+1)+" ist "+Rx1[c+1]+" "+Ry1[c+1]+" "+Rx2[c+1]+" "+Ry2[c+1]);
```
ausgibst, siehst du, welche Koordinaten er da verwendet (was ähnliches könnte man für's Dreieck machen). Wo die falschen Koordinaten herkommen, musst du dir aber selbst erschließen. 

Spontan (und ohne mir, wie man es bei der Programmierung eigentlich auch immer tun sollte  , tiefere Gedanken über den bestmöglichen Ansatz gemacht zu haben) : Überleg' mal, ob es nicht praktisch wäre, zwei Methoden zu haben wie

```
private void maleDreieckAnDieKante(Graphics g, Point p0, Point p1)
private void maleViereckAnDieKante(Graphics g, Point p0, Point p1)
```

Wenn die Daten wirklich gespeichert werden sollen, könntest du sie in einen Path2D packen - dann würde man etwas anders da drangehen. Aber vielleicht ist das gar nicht nötig :bahnhof:

Das ganze muss ja nicht auf ein Lindenmayer-System ? Wikipedia rauslaufen, aber vielleicht gibt es ja übersichtlichere Ansätze als Arrays


----------



## SlaterB (18. Jan 2011)

> sollten die Koordinaten des nächsten Rechtecks angepasst werden, aber stattdessen wird das erste völlig deformiert, was ich nicht so ganz verstehe.

wann und wie oft paint() ausgeführt wird, kannst du gar nicht kontrollieren,
wenn du c erhöhst und ein neues Rechteck setzt, so wird beim nächsten paint(), nachdem der Hintergrund gelöscht wurde,
das Rechteck mit diesem höheren c gemalt,

dir erscheint es als würde das erste deformiert werden, tatsächlich ist es das zweite, das erste wird gar nicht mehr gemalt

---

deine Methode init(Graphics) wird nie von irgendwem aufgerufen, mit der zur Überschreibung geeigneten Methode init() hat das nichts zu tun,
allgemein bietet sich an, init() zu überschreiben, dort einmalig alle Dinge auszurechnen,

paint(g) ändert keine Daten, malt exakt alles an zugehöriger Position, dann kann dir egal sein ob das 1x oder 3x ausgeführt wird,


----------



## Topblocker (18. Jan 2011)

Danke für die schnellen Antworten.

@Marco13:
Wenn ich in die paint-Methode ein System.out.println("..."); schreibe, wird bei mir nichts ausgegeben wenn ich das Applet starte, das war auch so etwas, was ich eigentlich fragen wollte^^ der Befehl scheint einfach ignoriert zu werden. :bahnhof:
Nein die einzelnen Koordinaten brauchen nicht gespeichert zu werden, die Arrays habe ich auch erst nachträglich eingefügt weil ich dachte, es hätte etwas damit zu tun, dass die erstellen Drei-, Vierecke ersetzt werden.
Das mit den Point-Typen klingt ganz gut, kennst du eine Seite, auf der das näher beschrieben wird? Hab auf Anhieb nichts gefunden.

@SlaterB:
Oh, dass der Hintergrund bei jedem Aufruf von paint() wieder gelöscht wird war mir garnicht bewusst.
Ok dann hatte ich das mit dem init() falsch verstanden.

Wäre dann die Koordinaten in einer gesonderten Methode alle zu bestimmen und anschließend per for-Schleife in der paint()-Methode auszugeben, ein besserer Ansatz?


----------



## SlaterB (18. Jan 2011)

Topblocker hat gesagt.:


> Wäre dann die Koordinaten in einer gesonderten Methode alle zu bestimmen und anschließend per for-Schleife in der paint()-Methode auszugeben, ein besserer Ansatz?


meiner Ansicht nach ja, denn das deckt sich mit meinem Vorschlag


----------



## Marco13 (18. Jan 2011)

Es gibt IMHO zwei mögliche Methoden dafür, die sich eigentlich vom Ansatz her ziemlich stark unterscheiden:
- Alles "on the fly" beim Zeichnen berechnen
- Alles berechnen und "in irgendwas zeichenbarem" (d.h. einem Shape) speichern.
Man kann aber auch darauf hinarbeiten, dass die Ansätze recht ähnlich sind.

Point liegt in java.awt.Point. Allgemeiner wäre Point2D.Double, aber das ist erstmal nicht so wichtig.

*rumspiel* 

```
import java.awt.*;
import java.applet.*;
import javax.swing.*;

public class SimpleLSystem extends JApplet
{
    public void paint(Graphics g)
    {
        paintTriangle(g, new Point(300,300), new Point(330, 300), 0, 20);
    }

    private void paintTriangle(Graphics g, Point p0, Point p1, int depth, int maxDepth)
    {
        if (depth == maxDepth)
        {
            return;
        }
        float dx = p1.x - p0.x;
        float dy = p1.y - p0.y;
        float cx = (float)(p0.x + dx * 0.5f);
        float cy = (float)(p0.y + dy * 0.5f);
        float tdx =  dy;
        float tdy = -dx;
        float s = 0.8f;
        float p2x = cx + tdx * s;
        float p2y = cy + tdy * s;
        Point p2 = new Point((int)p2x, (int)p2y);
        float v = (float)depth/(maxDepth-1);
        g.setColor(new Color(v,v,1));
        g.drawLine(p0.x, p0.y, p1.x, p1.y);
        g.drawLine(p1.x, p1.y, p2.x, p2.y);
        g.drawLine(p2.x, p2.y, p0.x, p0.y);
        if (((depth / 2) & 1) == 0)
        {
            paintRectangle(g, p0, p2, depth+1, maxDepth);
        }
        else
        {
            paintRectangle(g, p2, p1, depth+1, maxDepth);
        }
    }

    private void paintRectangle(Graphics g, Point p0, Point p1, int depth, int maxDepth)
    {
        if (depth == maxDepth)
        {
            return;
        }
        float dx = p1.x - p0.x;
        float dy = p1.y - p0.y;
        float tdx =  dy;
        float tdy = -dx;
        float p2x = p1.x + tdx;
        float p2y = p1.y + tdy;
        float p3x = p0.x + tdx;
        float p3y = p0.y + tdy;
        Point p2 = new Point((int)p2x, (int)p2y);
        Point p3 = new Point((int)p3x, (int)p3y);
        float v = (float)depth/(maxDepth-1);
        g.setColor(new Color(v,1,v));
        g.drawLine(p0.x, p0.y, p1.x, p1.y);
        g.drawLine(p1.x, p1.y, p2.x, p2.y);
        g.drawLine(p2.x, p2.y, p3.x, p3.y);
        g.drawLine(p3.x, p3.y, p0.x, p0.y);
        paintTriangle(g, p3, p2, depth+1, maxDepth);
    }
}
```


----------

