# Verpixelte Linie



## _-`avaj´-_ (12. Dez 2013)

Hallo liebes Forum,
ich habe folgendes Problem:
Ich will das Spiel Curve Fever "nachprogrammieren". Dabei zeichnet man eine Linie und kann steuern wohin sich diese bewegt.

Mein Problem ist, dass diese Linie zu verpixelt ist.
Ich habe schon 3 Varianten ausprobiert:

1) Die Linie ergibt sich aus vielen Kreisen, sprich immer wenn die Linie länger wird wird ein neuer Kreis gezeichnet. Das ganze ist dann aber leider zu verpixelt, weil das Antialiasing für so kleine Kreise (Durchmesser: 2-5 Pixel) zu gering ist.

2) Ich zeichne eine Polyline. Immer wenn sich die Linie um einen Pixel bewegt wird eine neuer Punkt hinzugefügt. Das ist verpixelt, weil das Antialiasing rumspinnt wenn so viele Punkte so nah beieinander sind.

3) Eine Polyline, bei der immer nur ein neuer Punkt hinzugefügt wird wenn sich die Richtung der Linie ändert, ansonsten wird der letzte Punkt durch die aktuelle Endposition der Linie ersetzt. Das gibt zwar keine Verpixelung bei Geraden, allerdings immer noch in Kurven und wichtiger: Die Linie "wackelt", da die Koordinaten ja nur auf einen Pixel genau sind.

Meine Frage also: Geht das ohne "Verpixelung" ?
PS: Antialiasing ist an 
	
	
	
	





```
.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
```
Und bei den Polylines ist die Stärke der Linie durch 
	
	
	
	





```
.setStroke(new BasicStroke(2));
```
 geändert.

Und noch der Code aus meiner Curve-Classe:


```
package core;

import gui.Drawable;
import gui.GamePanel;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics2D;
import java.util.ArrayList;

public class Curve implements Drawable {

	private ArrayList<Integer> xPoints;
	private ArrayList<Integer> yPoints;
	private Color c;

	private int r, speed;
	private double x, y, direction;

	public Curve(int x, int y, int r, int speed, double direction, Color c) {
		this.x = x;
		this.y = y;
		this.r = r;
		this.speed = speed;
		this.direction = direction;
		this.c = c;

		xPoints = new ArrayList<Integer>();
		yPoints = new ArrayList<Integer>();
		xPoints.add(x);
		yPoints.add(y);
		xPoints.add(x);
		yPoints.add(y);

		synchronized (GamePanel.list) {
			GamePanel.list.add(this);
		}
	}

	public void tick() {
		x += Math.cos(direction);
		y += Math.sin(direction);
		synchronized (this) {
			xPoints.add((int) x);
			yPoints.add((int) y);
		}
//		synchronized (this) {
//			xPoints.set(xPoints.size()-1,(int) x);
//			yPoints.set(yPoints.size()-1,(int) y);
//		}
	}

	public void changeDirection(int value) {
		direction += Math.toRadians(value);
//		synchronized (this) {
//			xPoints.add((int) x);
//			yPoints.add((int) y);
//		}
	}

	@Override
	public void draw(Graphics2D g) {		
		g.setStroke(new BasicStroke(2));
		synchronized (this) {
			int[] xp = new int[xPoints.size()];
			int[] yp = new int[yPoints.size()];
			for (int i = 0; i < xp.length; i++) {
				xp[i] = xPoints.get(i);
				yp[i] = yPoints.get(i);
			}
			g.drawPolyline(xp, yp, xp.length);
		}
	}
}
```


----------



## jemandzehage (22. Dez 2013)

Moin,

Könnte daran liegen, dass du nicht gesetzt hat, wie Antialiasing angewendet werden soll. Hab das zwar selber noch nicht ausprobiert, aber das hier Quick hit ? antialiasing in Java Graphics2D | Developmentality könnte dir weiterhelfen. 

Grüße


----------

