Swing [Erledigt] Bild schrittweise zoomen

[bj99]

Hallo, habe ein kleines Problem:

Ich will ein Bild vergrössern und es mit einem Thread zeichnen, und zwar so, dass es aussieht als würde es aufgezogen (also schrittweise grösser gemacht).
Eigentlich müsste der folgende Code funktionieren, doch es zeichnet mir die einzelnen Schritte nicht, sondern nur gleich das gezoomte Bild...

final int xp = xposm, yp = yposm;
				Thread t1 = new Thread(new Runnable() {
					public void run() {
						//Neue Position bestimmen
						double zvx = ((rix / 2) + 2 * (xp - (rix / 2)));
						double zvy = ((riy / 2) + 2 * (yp - (riy / 2)));
						double zvrx = ((rix / 2) - 2 * (xp - (rix / 2)));
						double zvry = ((riy / 2) - 2 * (yp - (riy / 2)));
						int[] zx1 = new int[11], zx2 = new int[11], zy1 = new int[11], zy2 = new int[11];
						for (int i = 0; i < 11; i++) {
							//positionen der einzelnen teilschritte in Arrays speichern
							zx1[i] = (int) (0 - zvx * (i / 10));
							zy1[i] = (int) (0 - zvy * (i / 10));
							zx2[i] = (int) (rix + zvrx * (i / 10));
							zy2[i] = (int) (riy + zvry * (i / 10));
						}
						Graphics2D agg = bild4.createGraphics();
						showbild1 = false;
						showbild4 = true;
						//bild zeichnen
						for (int i = 0; i < 11; i++) {
							agg.drawImage(bild3, zx1[i], zy1[i], zx2[i],
									zy2[i], 0, 0, rix * 2, riy * 2, null);
							repaint();
							try {
								//Pause, damit man auch was sieht
								Thread.sleep(100);
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
						showbild1 = true;
						agg.dispose();
					}
				});
				t1.start();

Seht ihr da vielleicht den fehler???

greez bj99

 

[André Uhres]

Von der Maltechnik her müsste es imho klappen. Der Fehler liegt wohl eher in der Berechnung. Z.B. ergibt [c](i / 10)[/c] immer 0, ausser wenn i gleich 10 ist, denn i ist ja ein int und kein double.

 

[bj99]

Von der Maltechnik her müsste es imho klappen. Der Fehler liegt wohl eher in der Berechnung. Z.B. ergibt [c](i / 10)[/c] immer 0, ausser wenn i gleich 10 ist, denn i ist ja ein int und kein double.

Yes, Danke viel mal, du bist gott ;-)

for (double i = 0; i < 11; i++) {
                            //positionen der einzelnen teilschritte in Arrays speichern
                            zx1[(int) i] = (int) (0 - zvx * (i / 10));
                            zy1[(int) i] = (int) (0 - zvy * (i / 10));
                            zx2[(int) i] = (int) (rix + zvrx * (i / 10));
                            zy2[(int) i] = (int) (riy + zvry * (i / 10));
                        }

So gehts... Juhui... Danke...

 

[Marco13]

Wo-ho eine Zählvariable als double zu deklarieren ist ... zumindest sehr unkonventionell, und in diesem Fall könnte das ganz, ganz übel schiefgehen: Bei der Schleife KÖNTE der double-Wert "i" vielleicht nacheinander folgende Werte annehmen:

1
2
3
4
4.999999999993543
5.99999999992543
6.9999999999992394
...

(in diesem konkreten Fall besteht dafür weniger die Gefahr, aber in ähnlichen Fällen könnte das passieren)

D.h. wenn diese Werte dann (auf int gecastet) als Array-Indizes verwendet werden, hätte man die Folge von Indizes

1
2
3
4
4 (!!!)
5 
6
...

Weil der Nachkommateil beim casten abgeschnitten wird. Man KÖNNTE da jetzt mit "Math.round" drauf einprügeln, aber das wäre :autsch: :noe:

Das "i" sollte nach wie vor ein int sein, aber die Zeilen sollten
zx2 = (int) (rix + zvrx * (i / 10.0));
lauten - durch das ".0" wird die Berechnung mit double-Werten gemacht, und erst ganz am Ende (durch das ganz außen stehende (int)) auf int gecastet.

Insgesamt könnte man so eine Schleife dann aber z.B. so schreiben:

int n = 11; // Einmal daklarieren - das macht spätere Änderungen einfacher
for (double i = 0; i < n; i++) 
{  
    double scaling = (double)i / (n-1); // Einmal ausrechnen - spart Zeit und Schreibarbeit, und ist übersichtlicher
    zx1[i] = (int) (0 - zvx * scaling);
    zy1[i] = (int) (0 - zvy * scaling);
    zx2[i] = (int) (rix + zvrx * scaling);
    zy2[i] = (int) (riy + zvry * scaling);
}

 

[bj99]

Danke, aber habs bereits kurz drauf selber gemerkt... habs nun so gemacht:

int[] zx1 = new int[11], zx2 = new int[11], zy1 = new int[11], zy2 = new int[101];
						for (int i = 0; i < 11; i++) {
							double j = (double) i/10;
							zx1[i] = (int) (0 - zvx * j);
							zy1[i] = (int) (0 - zvy * j);
							zx2[i] = (int) (rix + zvrx * j);
							zy2[i] = (int) (riy + zvry * j);
						}

Ziemlich deine Version...
und funktioniert sogar...

CU