# Grafische Objekte zeichnen



## Daniel_1988 (29. Dez 2010)

Hallo liebe Community,
ich habe folgendes Problem:

Ich habe eine vorgebene Datei "FigureDrawerTester", die ich erweitern soll, so dass das Programm auch funktioniert.
Es sollen Punkte, Linien, Rechtecke, Kreise und Polylinien gezeichnet werden.

Mein Hauptproblem liegt bei den Polylinien --> weis da nicht wie man das in der "class Polyline" gut verarbeiten kann.

Punkte einlesen: mit 2 Koordianten.
Linie: 2 Punkte
Kreis: 1 Punkt + Radius
Rechteck: 2 Punkte
diese sind ja noch verständlich, jedoch die Polylinie ist etwas anders:
Polylinie: Polyline(Linie[]) ... einlesen durch Linien.
oder
Polylinie: Polyline(Point[]) ...oder einlesen durch einzelne Punkte.
wie schreib ich das nun vernünftig???


(Haben gerade erst die Oberflächenprogrammierung gelernt, daher noch null plan, obwohl ich schon in meinen skripten geschmökert habe)

VORGEBENE JAVA-DATEI:

```
public class FigureDrawerTester {
  public static void main(String[] args) {
    Window.open();

    Point[] points = new Point[] {
      new Point(640, 25),
      new Point(660, 45),
      new Point(650, 65),
      new Point(670, 85)
    };
    for (int i = 0; i < points.length; i++) {
      points[i].draw();
    }

    Line line = new Line(new Point(10, 10), new Point(650, 20));
    line.draw();
    
    Rectangle rectangle = new Rectangle(new Point(45, 225), 100, 100);
    rectangle.draw();
    
    Circle circle = new Circle(new Point(300, 300), 70);
    circle.draw();
    
    Polyline[] polyLines = new Polyline[6];
    polyLines[0] = createTriangle();
    polyLines[1] = createRectangle();
    polyLines[2] = createPentagon(300, 300);
    polyLines[3] = createStar(500, 300);
    polyLines[4] = createCross();
    polyLines[5] = createPlus();
    
    for (int i = 0; i < polyLines.length; i++) {
      polyLines[i].draw();
    }
  }
  
  private static Polyline createTriangle() {
    return new Polyline(
      new Point[] {
        new Point(120, 50),
        new Point(220, 150),
        new Point(20, 150)
      });
  }
  
  private static Polyline createRectangle() {
    return new Polyline(
      new Point[] {
        new Point(20, 200),
        new Point(170, 200), 
        new Point(170, 350), 
        new Point(20, 350) });
  }

  private static Point[] createPentagon0(int offsetX, int offsetY) {
    int spikes = 5;
    int angle = 360 / spikes;
    int radius = 100;
    Point[] points = new Point[spikes];
    for(int i=0;  i < spikes; i++) {
      Point p = new Point(
        offsetX + (int) (radius * Math.cos(Math.toRadians(360 - angle * i))),
        offsetY + (int) (radius * Math.sin(Math.toRadians(360 - angle * i))));
      points[i] = p;
    }
    return points;
  }
  
  private static Polyline createPentagon(int offsetX, int offsetY) {
    return new Polyline(createPentagon0(offsetX, offsetY));
  }

  private static Polyline createStar(int offsetX, int offsetY) {
    Point[] points = createPentagon0(offsetX, offsetY);
    return new Polyline(
      new Line[] {
        new Line(points[0], points[2]),
        new Line(points[1], points[3]),
        new Line(points[2], points[4]),
        new Line(points[3], points[0]),
        new Line(points[4], points[1])
      }
    );
  }
  
  private static Polyline createCross() {
    return new Polyline(
      new Line[] {
        new Line(new Point(250, 50), new Point(350, 150)),
        new Line(new Point(250, 150), new Point(350, 50))
      }
    );
  }
  
  private static Polyline createPlus() {
    return new Polyline(
      new Line[] {
        new Line(new Point(450, 100), new Point(550, 100)),
        new Line(new Point(500, 50), new Point(500, 150))
      }
    );
  }
}
```

Eigentlich muss ich ja da nicht wirklich viel dazu programmieren denke ich, da das meiste ja schon im Testprogramm steht.

Das habe ich mal geschrieben:


```
class Point{
	public int pointX;
	public int pointY;
	
	Point(int pointX, int pointY){
		this.pointX = pointX;
		this.pointY = pointY;
	}
}
class Line{
	public Point linePoint1;
	public Point linePoint2;
	
	Line(Point linePoint1, Point linePoint2){
		this.linePoint1 = linePoint1;
		this.linePoint2 = linePoint2;
	}
}
class Polyline{
	public Line[] linePolyline;
	public int countPolyline;
	
	Polyline(Line[] linePolyline, int countPolyline){
		this.linePolyline = linePolyline;
		this.countPolyline = countPolyline;
	}
}
class Rectangle{
	public Point pointRectangle;
	public int width;
	public int height;
	
	Rectangle(Point pointRectangle, int width, int height){
		this.pointRectangle = pointRectangle;
		this.width = width;
		this.height = height;
	}
}
class Circle{
	public Point circlePoint;
	public int radius;
	
	Circle(Point circlePoint, int radius){
		this.circlePoint = circlePoint;
		this.radius = radius;
	}
}
```

Ist das soweit korrekt?

Jetzt fehlt mir auch noch eine Methode zum zeichnen --> "draw"
Wie kann diese aussehen? Es muss ja immer etwas anderes gezeichnet werden, je nachdem was der anwender will?
Muss da für jede Art von Figur ne eigene draw Methode geschrieben werden??

Grüße Daniel


----------



## DerEisteeTrinker (29. Dez 2010)

Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 17 Grafikprogrammierung

da wird dir gehelft


----------



## Daniel_1988 (29. Dez 2010)

Danke, da hab ich schon geschaut.

Zu meinem Programmtext bisher, passt das so?
Das mit der Polylinie, wie muss ich das korrekt schreiben, es funkt so einfach nicht!?


----------



## Sneek (29. Dez 2010)

Also, ich kann momentan zu deinem Problem nur soviel beitragen:

Du musst für jede Figur eine eigene .draw()-Methode erstellen, die implementierst du einfach in die entsprechenden Klassen. Wie die .draw() konkret aussehen muss, kann ich dir gerade nicht sagen.


----------



## Marco13 (29. Dez 2010)

Polyline(Point[]) und Polyline(Line[]) brauchst du beides.... oder was war die Frage ???:L


----------

