Swing Skalieren mit DrawImage macht Linien kaputt

[P@u1]

Hallo zusammen,

habe mal wieder ein Swing-Problem:
Ich habe ein Bild, dass aus vielen Linien besteht in ein BufferedImage gemalt, nun will ich es je nach aktueller Größe des Fensters richtig skaliert zeichnen.
Das Problem ist:
Linien, die zuvor mit DrawLine gemalt wurden werden zerstückelt, also haben auf einmal Lücken, so ungefähr:

vorher: --------------------------------- (wir nehmen jetzt an, dass die Striche direkt verbunden sind)
nachher: --- --- --- --- --- --- --- (die Lücken sind eigentlich nicht ganz regelmäßig verteilt)

Und ich bin mir 99% sicher, dass es am skalieren liegt, ich hab testweise einfach mal eine einzelne Linie gezeichnet von (0,0) zu (1000,1000) und dort trat der gleiche effekt auf.
Benutze ich die DrawImage funktion ohne angabe der größe, so wird nicht skaliert und der Effekt tritt nicht auf.
Was kann ich da jetzt machen?
Das mit dem skalieren ist mir schon wichtig und das manuell zu machen ist vermutlich aufwändig und langsam.
Irgendwelche Ideen?

Vielen Dank schonmal für Antworten

 

[Runtime]

Wenn du die Linien schön haben willst, wirst es nochmal neu zeichnen müssen, aber wenn es unbedingt so sein muss könntest du den Effekt verringern, indem du eine Liste mit verschieden grossen BufferedImages hast und immer das zeichnest, welches der Grösse des Fensters am nächsten kommt.

 

[P@u1]

hmmm, alles nicht so prickelnd.
Ich überlege jetzt folgendes:
Ich speicher mir alle Linien als Objekte in einer Liste ab, dann benutze ich einen componentResizedListener, der sobald sich die Größe des ZielPanels ändert ein neues bufferedimage erzeugt, auf den die sachen mit neuer skalierung gezeichnet werden.
Ich will später auch nur die y-Achse skalieren, von der x-Achse nehme ich dann immer nur einen so großen Ausschnitt, wie aufs Bild passt.

Problem ist nur, dass componentResized während man die größe verändert extrem oft ausgeführt wird, ich bräuchte was, was am besten erst aufgerufen wird, wenn das verändern der größe abgeschlossen ist.
Evtl. nen Timer, der beim aufruf von componentresized gestartet wird und bei jedem weiteren aufruf zurückgesetzt wird?

Hast du vll noch gute Ideen, die mir helfen könnten?

 

[Guybrush Threepwood]

Welche Einstellungen zum Antialiasing hast Du verwendet? Wende mal den folgenden Code auf Dein Graphics-Objekt an:

Graphics2D g2d = ...;
		g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
				RenderingHints.VALUE_INTERPOLATION_BILINEAR);
		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

Das kostet mehr Rechenleistung, bringt aber bessere Ergebnisse beimn Skalieren.

 

[Marco13]

Das problem, das du beschreibst, ist vermutlich das, was man als "aliasing" bezeichnet. Wenn man eine Linie malt

X
 X
  X
   X 
    X
     X
      X

und diese Bild dann um die Hälfte niedriger macht, fällt (im einfachsten Fall) jeder zweite Pixel weg

X
 X
   X
     X

Man kann dem Teilweise entgegen wirken, indem man beim Zeichnen entweder Antialiasing im Graphics2D einschaltet, oder andere RenderingHints passend setzt (schau mal in derf Nähe von dem hier). Wie genau man das am besten einstellt, hängt auch davon ab, wie es jetzt gezeichnet wird, und ggf. müßte ich auch erst ein bißchen rumprobieren... Und wie gut die Ergebnisse (besonders bei starken Größenänderungen) im Vergleich zum Neuzeichnen sind, bleibt auch erstmal offen...

EDIT: Ein bißchen langsam

 

[P@u1]

Welche Einstellungen zum Antialiasing hast Du verwendet? Wende mal den folgenden Code auf Dein Graphics-Objekt an:

Graphics2D g2d = ...;
		g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
				RenderingHints.VALUE_INTERPOLATION_BILINEAR);
		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

Das kostet mehr Rechenleistung, bringt aber bessere Ergebnisse beimn Skalieren.

Danke, die Linie bleibt jetzt erhalten, nur leider wird sie dadurch etwas dicker, was eigentlich nicht gewünscht ist und wirkt aus einzelteilen zusammengesetzt.
Wenn ihr noch tipps habt, was ich noch ändern kann, probier ichs mal aus, ansonsten werde ich vermutlich die die zweite variante versuchen.

Edit: Ich hatte nur bei der einen Linie getestet, da wird es wirklcih besser, aber dann hab ich nochmal ein anwendungsnäheres Beispiel benutzt, ein Sinus der aus vielen kleinen Linien zusammengestzt ist und auch mit den Einstellungen tritt der Effekt ein, dass die Linien "zerstückelt" werden.
Ich denke mal, es wäre dann doch besser den anderen Weg zu gehen über diese Objektliste und aktualisieren bei Größenänderung.
Nur muss ich noch gucken, wie genau ich das dann mache.

Wenn ich die Größe des Fensters durch ziehen der Maus verändere, wird normalerweise (bei kurzem code) das ComponentResizeEvent sehr sehr oft ausgelöst.
Wie funktioniert das wenn ich einen componentResizeListener verwende und in dem code davon lange berechnungen mache?
Wird das dann auch ganz oft aufgerufen und die folgenden Aufrufe müssen "warten" und werden angehängt, oder werden die folgenden Aufrufe einfach ignoriert, oder wie funktioniert das?

Das Problem ist ja, dass ich bei diesem Event das ganze BufferedImage neumachen will, was vermutlich relativ lange dauert und falls bei einem resizevorgang das dann tausen mal aufgerufen wird und die aufrufe hintereinander alle abgearbeitet werden würden, dann würde das sehr lange dauern.
Würden aber die Aufrufe die kommen während die Methode läuft nicht mehr ausgeführt werden, wäre das auich schlecht, weil dann ein neues Image erzeugt wird, währenddessen sich die größe weiter verändert, aber dann das Image auf falscher Größe bleibt.

 

[Guybrush Threepwood]

Im Grunde erhält man immer bessere Ergebnisse, wenn völlig neu gezeichnet und nicht skaliert wird. Dabei wirst Du wahrscheinlich meistens einen Qualitätsverlust erleiden. Ob das Neuzeichnen zu langsam ist hängt vermutlich von der Größe des Bildes und der Menge an Objekten ab. Wenn Du mit Java2D zeichnest, dann geht es aber meist sehr sehr schnell. Das Problem ist eher das hantieren mit Bitmaps etc. Wenn Du verhindern möchtest, dass beim Größerziehen ständig neu gezeichnet wird, dann könntest Du z. B. über das Setzen einer boolean-Variable in der Zeichen-Routine festhalten, ob noch eine Verarbeitung im Gange ist. In der PaintComponent-Methode wäre es dann möglich, dies abzufragen und ein Neuzeichnen zu verhindern, falls gerade noch eine alte Zeichnung vorbereitet wird, oder so ähnlich. Alternativ könnte auch bei einem ComponentResizeEvent eine bereits in Arbeit befindliche Neuzeichnung unterbrochen werden. Es gibt da sicher viele Möglichkeiten.