Zoom per Tastatur

[thisisme]

Hallo zusammen!

Vielleicht könnt ihr mir helfen:
ich suche eine Möglichkeit, einen Zoom über die Tastatur zu steuern, habe bisher aber nur Möglichkeiten gefunden, dieses über die Maus zu machen.
Ich habe in meiner Application einen ColorCube und möchte diesen gerne rein- bzw. rauszoomen.

Meine Idee war, eine eigene Behaviour-Klasse zu schreiben, die die Skalierung des Würfels ändert:

private class MyZoom extends Behavior {

		private TransformGroup targetTG;
		Transform3D trans = new Transform3D();
		double myscale = 0.4;
		
		@Override
		public void initialize() {
			this.wakeupOn(new WakeupOnAWTEvent(KeyEvent.KEY_PRESSED));		
			
		}

		@Override
		public void processStimulus(Enumeration arg0) {
			WakeupOnAWTEvent event = (WakeupOnAWTEvent) arg0.nextElement();

			switch(pressedKey) {  // etwas abgekuerzt, richtige Taste wird erkannt
			case 'p': 
				myscale -= 0.1;
				trans.setScale(new Vector3d(myscale, myscale, myscale));
				targetTG.setTransform(trans); 
			}
			wakeupOn(new WakeupOnAWTEvent(KeyEvent.KEY_PRESSED));
		}
		
		public MyZoom(TransformGroup targetTG) {
			this.targetTG = targetTG;
		}

Sobald ich den Würfel jedoch vorher drehe, ist die gedrehte Ansicht danach (natürlich) nicht mehr erhalten, habt ihr eine Idee? Oder gibt es einen einfacheren/besseren Ansatz?

Vielen Dank!

 

[Illuvatar]

Ich weiß nicht wie dein Code aussieht, aber müsste es nicht möglich sein, aus Drehung und Scale 2 verschiedene TransformGroups machen, wo dann das eine nicht durch das andere beinflusst würde?

Oder du machst vor Zeile 20 mal targetTG.getTransform(trans).

 

[Guest]

Oder du machst vor Zeile 20 mal targetTG.getTransform(trans).

Hey super, vielen Dank! Jetzt bleibt die Dreshung erhalten. Vielleicht kannst du mir noch mal helfen:
mein ZoomOut klappt, d.h. mein Würfel wird schrittweise immer kleiner. Beim ZoomIn hab ich allerdings Probleme, obwohl meine Berechnung in meinen Augen stimmen müsste, wird auch hier der Würfel immer kleiner. Im Moment führe ich beide Fälle nur getrennt voneinander aus, also nur reinzoomen oder nur rauszoomen nicht erst rein, dann wieder raus etc.

private class MyZoom extends Behavior {
		private TransformGroup targetTG;
		Transform3D trans = new Transform3D();
		Transform3D transTemp = new Transform3D();
		double xAlt = 0.4; // Ursprungsgroessen des Wuerfels

		@Override
		public void initialize() { ... }

		@Override
		public void processStimulus(Enumeration arg0) {
			
			char c = // gedrueckte Taste
			transTemp.set(trans);

			switch(c) {
                        // ZOOM OUT
			case 'o':
				double xNeu = xAlt - 0.1;
				double a = xNeu / xAlt;
				xAlt = xNeu;
				targetTG.getTransform(trans);
				trans.setScale(new Vector3d(a, a, a));
				targetTG.setTransform(trans); 
				break;
			// ZOOM IN	
			case 'i': 
				double xNeu2 = xAlt + 0.1;
				double a2 = xNeu2 / xAlt;
				xAlt = xNeu2;
				targetTG.getTransform(trans);
				trans.setScale(new Vector3d(a2, a2, a2));
				targetTG.setTransform(trans); 
				break;
			}
			wakeupOn(new WakeupOnAWTEvent(KeyEvent.KEY_PRESSED));
		}
		
		public MyZoom(TransformGroup targetTG) {
			this.targetTG = targetTG;
		}
		
	}

 

[thisisme]

Etwas verspätet hier die Lösung (falls jemand mal sowas gebrauchen kann ;-)):

public class Zoom extends Behavior {


	private TransformGroup targetTG;
	private double oldSize;
	private final double DELTA = 1E-16;
	private double zoomStep;

	public Zoom(TransformGroup targetTG, double cubeSize) {
		this.targetTG = targetTG;
		oldSize = cubeSize;
		zoomStep = 0.1;
	}

	public void initialize() {...}

	public void processStimulus(Enumeration arg0) {
		[...]
		char c = key.getKeyChar();
		double newSize;
		switch(c) {
		case 'o':
			newSize = oldSize - zoomStep;
			if(newSize > DELTA) {
				zoom(newSize);
			}
			break;
		case 'i': 
			newSize = oldSize + zoomStep;
			zoom(newSize);
		}
		initialize();
	}

	private void zoom(double newSize) {
		Transform3D trans = new Transform3D();
		Transform3D transScale = new Transform3D();
		targetTG.getTransform(transScale);
		double factor = newSize / oldSize;
		trans.setScale(factor);
		trans.mul(transScale);
		oldSize = newSize;
		targetTG.setTransform(trans); 
	}
}

@Moderatoren: kann jemand von euch das Thema als "gelöst" markieren? Ich kann das nicht, weil ich den Thread als Gast gestartet hab

 

[Guest]

Hallo zusammen!

Vielleicht könnt ihr mir helfen:
ich suche eine Möglichkeit, einen Zoom über die Tastatur zu steuern, habe bisher aber nur Möglichkeiten gefunden, dieses über die Maus zu machen.
Ich habe in meiner Application einen ColorCube und möchte diesen gerne rein- bzw. rauszoomen.

Meine Idee war, eine eigene Behaviour-Klasse zu schreiben, die die Skalierung des Würfels ändert:

private class MyZoom extends Behavior {

		private TransformGroup targetTG;
		Transform3D trans = new Transform3D();
		double myscale = 0.4;
		
		@Override
		public void initialize() {
			this.wakeupOn(new WakeupOnAWTEvent(KeyEvent.KEY_PRESSED));		
			
		}

		@Override
		public void processStimulus(Enumeration arg0) {
			WakeupOnAWTEvent event = (WakeupOnAWTEvent) arg0.nextElement();

			switch(pressedKey) {  // etwas abgekuerzt, richtige Taste wird erkannt
			case 'p': 
				myscale -= 0.1;
				trans.setScale(new Vector3d(myscale, myscale, myscale));
				targetTG.setTransform(trans); 
			}
			wakeupOn(new WakeupOnAWTEvent(KeyEvent.KEY_PRESSED));
		}
		
		public MyZoom(TransformGroup targetTG) {
			this.targetTG = targetTG;
		}

Sobald ich den Würfel jedoch vorher drehe, ist die gedrehte Ansicht danach (natürlich) nicht mehr erhalten, habt ihr eine Idee? Oder gibt es einen einfacheren/besseren Ansatz?

Vielen Dank!