Swing Bild an Fenstergröße skalieren

[ProChris]

Hallo,

ich beschäftige mich gerade mit dem erzeugen einer GUI unter Java. Dazu habe ich mir ein JFrame gebaut, auf dem ein JLabel liegt, um ein Bild anzeigen zu können. Meine Vorstellung ist, dass sich das Bild mit der Fenstergröße skalliert. Dabei ist folgendes zu beachten:

• das Fenster darf nicht größer skalliert werden, als das Bild (um Verpixelungen zu vermeiden)
• das Bild hat eine Auflösung von 1440 * 900, somit ein Seitenverhältnis von 1,6

Angenommen ich skalliere die Breite auf 1000, so muss die Höhe Automatisch auf 625 gesetzte werden. (Um verzerrungen zu vermeiden)

Könnt ihr mir ein paat Tipps geben, wie ich soetwas lösen kann?

PS: Ich frage nicht, weil ich nicht weiss wie es geht. Ich frage, weil ich zu meiner "Delphi-Zeit" sowas von Hand programmiert habe, bis ich erfahren musste, dass eine Eigenschaft nur auf true gesetzt werden muss, um genau diese Funktionalität zu erhalten.

Viele Grüße

ProChris

 

[Gast2]

Ich würde dafür die Klasse JPanel erweitern und in dessen paintComponent() dann das Bild zeichnen. Da kannst du dir per getWidth() und getHeight() direkt die aktuelle Größe der Komponente holen und das Bild entsprechend skalieren. Vermutlich musst du dir die skalierten Instanzen irgendwo in ner Map speichern, weil das doch recht aufwendig ist.

Was fertiges gibts dafür meines wissens nicht.

 

[pro2]

Wenn das Bild immer ein Seitenverhältnis von 1,6 hat, kann er sein y ja eig. immer auf

getWidth() / 1.6

z. B. setzen, oder? Ansonsten müsste er halt nur das Seitenverhältnis vom Ursprungsbild vorher bestimmen.

 

[Gast2]

von welchem y sprichst du da?

 

[pro2]

Ach y, ich meine natürlich die Breite bzw. die Höhe des Bildes, je nachdem, ob oben/unten oder an der Seite gequetscht wird.

 

[Gast2]

Ja klar, die Werte müssen berechnet werden, aber das ist ja trivial. Danach muss das Bild aber dann noch auf die Werte skaliert werden und danach kanns gezeichnet werden.

 

[bERt0r]

The Perils of Image.getScaledInstance() | Java.net

 

[Gast2]

Hier mal auf die schnelle hingeklatscht:

public class ScalableImagePanel extends JPanel {

	private final Image image;
	private final int IMAGE_HEIGHT;
	private final int IMAGE_WIDTH;


	public ScalableImagePanel(Image image) {
		this.image = image;
		
		IMAGE_HEIGHT = image.getHeight(this);
		IMAGE_WIDTH = image.getWidth(this);
	}
	
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		
		Image scaledInstance = getScaledInstance();
		
		int x = (int)((getWidth() - scaledInstance.getWidth(this)) / 2.0);
		int y = (int)((getHeight() - scaledInstance.getHeight(this)) / 2.0);
		g.drawImage(scaledInstance, x, y, this);
	}
	
	private Image getScaledInstance() {
		double factor = (double)IMAGE_HEIGHT / IMAGE_WIDTH;
		boolean scaleXAxis = (double)getHeight() / getWidth() > factor;
		
		int width = 0;
		int height = 0;
		if (scaleXAxis) {
			width = Math.min(getWidth(), IMAGE_WIDTH);
			height = (int)(width * factor);			
		} else {
			height = Math.min(getHeight(), IMAGE_HEIGHT);
			width = (int)(height / factor);
		}
		
		return image.getScaledInstance(width, height, 0);
	}
}

Wie gesagt kann man die skalierten noch cachen damit man die nicht dauernt neu skaliert. Und man sicherlich noch das ein oder andere verbessern

 

[ProChris]

Hallo,

technisch habe ich eine kleine Lösung implementiert, die mir die Fenstergröße im vorgegebenen Seitenverhältnis berechnet und setzt. Wenn ich das Programm starte, dass sieht auch alles super aus. Sobald ich das Fenster vergrößern möchte fängt es wild an zu blinken. Habt ihr eine Idee dazu?

			@Override
			public void componentResized(ComponentEvent arg0) {
				final Dimension dimension = frame.getSize();
				
				final int currentWidth = dimension.width;
				final int currentHeight = dimension.height;

				final double newWidth = 1.6 * currentHeight;
				final double newHeight = currentWidth / 1.6;
				
				dimension.width = (int)newWidth;
				dimension.height = (int)newHeight;
				
				frame.setSize(dimension);
			}

Viele Grüße

ProChris

 

[bERt0r]

Schau dir meinen link an, steht so in einem Auszug:

On-The-Fly Scaling

As previously stated, the right scaling approach often depends on the context. For the purposes of this discussion, I will highlight the two most common strategies. I call the first approach "on-the-fly" scaling because it is generally used in dynamic situations. For example, you may want to scale a bunch of images as part of an animation sequence. Or you may have a custom component that lets the user zoom in on and out of an image. In these cases, the scale factor is constantly changing, so it does not make much sense to cache a scaled instance of the image at each size. Instead, we can simply use the scaling variant of Graphics.drawImage() to scale an image into the destination (e.g. a custom Swing component, or perhaps an offscreen image that will later be saved to disk):

    private float xScaleFactor, yScaleFactor = ...;
    private BufferedImage originalImage = ...;

    public void paintComponent(Graphics g) {
        Graphics2D g2 = (Graphics2D)g;
        int newW = (int)(originalImage.getWidth() * xScaleFactor);
        int newH = (int)(originalImage.getHeight() * yScaleFactor);
        g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                            RenderingHints.VALUE_INTERPOLATION_BILINEAR);
        g2.drawImage(originalImage, 0, 0, newW, newH, null);
    }

 

[ProChris]

Hallo,

ich habe doch nocht gar nicht von irgendeinem Bild gesprochen. Ich versuche mich gerade daran, dass Fenster ohne Flackern und unter den gegebenen Bedingungen zu implementieren. Ich denke bevor man mit dem eigentlichen Problem beginnen kann, sollte man sich ersteinmal um das Fenster ansich kümmern. (Also um das Skalieren mit dem Seitenverhältnis 1,6)

Viele Grüße

ProChris

 

[bERt0r]

Normalerweise versucht man nicht ein vergrößerbares Fenster in eine Größe zu zwingen, wenn doch hast du entweder das flackern mit deinem Code, oder musst dir einen undecorated Frame schreiben, der das unterstützt. Schau mal im Forum, das gleiche kam vor ein paar wochen auf.

Viel schöner ist es mMn. sich am Verhalten von so gut wie jeder anderen professionellen Anwendung zu orientieren, und einfach einen leeren Bereich anzuzeigen, wenn das Fenster unproportional wird. Das heisst in deinem Frame liegt ein Panel, das immer deine Proportionen einhält, und wenn der Benutzer meint er muss es 5 so hoch machen, sieht er unter deinem Panel, wo alle GUI elemente inklusive deines Bildes drin sind, einen grauen Bereich.